diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro
index 2b2f24ba53..d3500ab144 100644
--- a/include/xrpl/protocol/detail/features.macro
+++ b/include/xrpl/protocol/detail/features.macro
@@ -15,6 +15,7 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
+XRPL_FIX    (Cleanup3_3_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_2_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV2,                  Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_1_3,                Supported::Yes, VoteBehavior::DefaultYes)
diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp
index b7defb4df8..ecc8416a2b 100644
--- a/src/libxrpl/tx/paths/OfferStream.cpp
+++ b/src/libxrpl/tx/paths/OfferStream.cpp
@@ -17,6 +17,7 @@
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Book.h>
 #include <xrpl/protocol/Concepts.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/MPTAmount.h>
@@ -249,7 +250,13 @@ TOfferStreamBase<TIn, TOut>::step()
             continue;
         }
 
-        if (entry->isFieldPresent(sfDomainID) &&
+        // Pre-fixCleanup3_3_0: validate domain membership for any book.
+        // Post-fixCleanup3_3_0: only validate when walking a domain book.
+        // Hybrid offers carry sfDomainID but also participate in the open
+        // book; expiry of the owner's domain credential should not evict
+        // the offer from the open book.
+        if ((!view_.rules().enabled(fixCleanup3_3_0) || book_.domain.has_value()) &&
+            entry->isFieldPresent(sfDomainID) &&
             !permissioned_dex::offerInDomain(
                 view_, entry->key(), entry->getFieldH256(sfDomainID), j_))
         {
diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp
index d534f20248..99e69ce482 100644
--- a/src/test/app/PermissionedDEX_test.cpp
+++ b/src/test/app/PermissionedDEX_test.cpp
@@ -185,15 +185,15 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // test preflight
         {
             Env env(*this, features - featurePermissionedDEX);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID), Ter(temDISABLED));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID), Ter(temDISABLED));
             env.close();
 
             env.enableFeature(featurePermissionedDEX);
             env.close();
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
         }
 
@@ -214,7 +214,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // preclaim - someone outside of the domain cannot create domain offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
@@ -223,7 +223,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             env(offer(devin, XRP(10), USD(10)), Domain(domainID), Ter(tecNO_PERMISSION));
@@ -247,7 +247,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // preclaim - someone with expired cred cannot create domain offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
@@ -256,7 +256,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             auto jv = credentials::create(devin, domainOwner, credType);
@@ -282,13 +282,13 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // preclaim - cannot create an offer in a non existent domain
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
             uint256 const badDomain{
                 "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134"
                 "E5"};
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(badDomain), Ter(tecNO_PERMISSION));
+            env(offer(bob, XRP(10), USD(10)), Domain(badDomain), Ter(tecNO_PERMISSION));
             env.close();
         }
 
@@ -296,68 +296,68 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // domain
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(credentials::deleteCred(domainOwner, gw_, domainOwner, credType));
+            env(credentials::deleteCred(domainOwner, gw, domainOwner, credType));
             env.close();
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
         }
 
         // apply - offer can be created even if takerpays issuer is not in
         // domain
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(credentials::deleteCred(domainOwner, gw_, domainOwner, credType));
+            env(credentials::deleteCred(domainOwner, gw, domainOwner, credType));
             env.close();
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, USD(10), XRP(10)), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, USD(10), XRP(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, USD(10), XRP(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, USD(10), XRP(10), 0, true));
         }
 
         // apply - two domain offers cross with each other
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
-            BEAST_EXPECT(ownerCount(env, bob_) == 3);
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(ownerCount(env, bob) == 3);
 
             // a non domain offer cannot cross with domain offer
-            env(offer(carol_, USD(10), XRP(10)));
+            env(offer(carol, USD(10), XRP(10)));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
 
-            auto const aliceOfferSeq{env.seq(alice_)};
-            env(offer(alice_, USD(10), XRP(10)), Domain(domainID));
+            auto const aliceOfferSeq{env.seq(alice)};
+            env(offer(alice, USD(10), XRP(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, alice_, aliceOfferSeq));
-            BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, alice_) == 2);
+            BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, alice) == 2);
         }
 
         // apply - create lots of domain offers
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             std::vector<std::uint32_t> offerSeqs;
@@ -365,19 +365,19 @@ class PermissionedDEX_test : public beast::unit_test::Suite
 
             for (size_t i = 0; i <= 100; i++)
             {
-                auto const bobOfferSeq{env.seq(bob_)};
+                auto const bobOfferSeq{env.seq(bob)};
                 offerSeqs.emplace_back(bobOfferSeq);
 
-                env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+                env(offer(bob, XRP(10), USD(10)), Domain(domainID));
                 env.close();
-                BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
+                BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
             }
 
             for (auto const offerSeq : offerSeqs)
             {
-                env(offerCancel(bob_, offerSeq));
+                env(offerCancel(bob, offerSeq));
                 env.close();
-                BEAST_EXPECT(!offerExists(env, bob_, offerSeq));
+                BEAST_EXPECT(!offerExists(env, bob, offerSeq));
             }
         }
     }
@@ -390,10 +390,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // test preflight - without enabling featurePermissionedDEX amendment
         {
             Env env(*this, features - featurePermissionedDEX);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(pay(bob_, alice_, USD(10)),
+            env(pay(bob, alice, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -403,10 +403,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.enableFeature(featurePermissionedDEX);
             env.close();
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            env(pay(bob_, alice_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(bob, alice, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
         }
 
@@ -431,13 +431,13 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // preclaim - cannot send payment with non existent domain
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
             uint256 const badDomain{
                 "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134"
                 "E5"};
 
-            env(pay(bob_, alice_, USD(10)),
+            env(pay(bob, alice, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(badDomain),
@@ -448,10 +448,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // preclaim - payment with non-domain destination fails
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
             // create devin account who is not part of the domain
@@ -460,11 +460,11 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             // devin is not part of domain
-            env(pay(alice_, devin, USD(10)),
+            env(pay(alice, devin, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -476,7 +476,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // devin has not yet accepted cred
-            env(pay(alice_, devin, USD(10)),
+            env(pay(alice, devin, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -487,17 +487,17 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // devin can now receive payment after he is in domain
-            env(pay(alice_, devin, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(alice, devin, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
         }
 
         // preclaim - non-domain sender cannot send payment
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
             // create devin account who is not part of the domain
@@ -506,11 +506,11 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             // devin tries to send domain payment
-            env(pay(devin, alice_, USD(10)),
+            env(pay(devin, alice, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -522,7 +522,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // devin has not yet accepted cred
-            env(pay(devin, alice_, USD(10)),
+            env(pay(devin, alice, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -533,28 +533,28 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // devin can now send payment after he is in domain
-            env(pay(devin, alice_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(devin, alice, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
         }
 
         // apply - domain owner can always send and receive domain payment
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
             // domain owner can always be destination
-            env(pay(alice_, domainOwner, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(alice, domainOwner, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
             // domain owner can send
-            env(pay(domainOwner, alice_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(domainOwner, alice, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
         }
     }
@@ -567,22 +567,22 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // test domain cross currency payment consuming one offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // create a regular offer without domain
-            auto const regularOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)));
+            auto const regularOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, XRP(10), USD(10)));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
 
-            auto const regularDirKey = getDefaultOfferDirKey(env, bob_, regularOfferSeq);
+            auto const regularDirKey = getDefaultOfferDirKey(env, bob, regularOfferSeq);
             BEAST_EXPECT(regularDirKey);
             BEAST_EXPECT(checkDirectorySize(
                 env, *regularDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
 
             // a domain payment cannot consume regular offers
-            env(pay(alice_, carol_, USD(10)),
+            env(pay(alice, carol, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
@@ -590,23 +590,23 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // create a domain offer
-            auto const domainOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const domainOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, domainOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, domainOfferSeq, XRP(10), USD(10), 0, true));
 
-            auto const domainDirKey = getDefaultOfferDirKey(env, bob_, domainOfferSeq);
+            auto const domainDirKey = getDefaultOfferDirKey(env, bob, domainOfferSeq);
             BEAST_EXPECT(domainDirKey);
             BEAST_EXPECT(checkDirectorySize(
                 env, *domainDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
 
             // cross-currency permissioned payment consumed
             // domain offer instead of regular offer
-            env(pay(alice_, carol_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(alice, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(!offerExists(env, bob_, domainOfferSeq));
-            BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, XRP(10), USD(10)));
+            BEAST_EXPECT(!offerExists(env, bob, domainOfferSeq));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
 
             // domain directory is empty
             BEAST_EXPECT(checkDirectorySize(
@@ -618,79 +618,79 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // test domain payment consuming two offers in the path
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const eur = gw_["EUR"];
-            env.trust(eur(1000), alice_);
+            auto const eur = gw["EUR"];
+            env.trust(eur(1000), alice);
             env.close();
-            env.trust(eur(1000), bob_);
+            env.trust(eur(1000), bob);
             env.close();
-            env.trust(eur(1000), carol_);
+            env.trust(eur(1000), carol);
             env.close();
-            env(pay(gw_, bob_, eur(100)));
+            env(pay(gw, bob, eur(100)));
             env.close();
 
             // create XRP/USD domain offer
-            auto const usdOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const usdOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(10), USD(10), 0, true));
 
             // payment fail because there isn't eur offer
-            env(pay(alice_, carol_, eur(10)),
+            env(pay(alice, carol, eur(10)),
                 Path(~USD, ~eur),
                 Sendmax(XRP(10)),
                 Domain(domainID),
                 Ter(tecPATH_PARTIAL));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(10), USD(10), 0, true));
 
-            // bob_ creates a regular USD/EUR offer
-            auto const regularOfferSeq{env.seq(bob_)};
-            env(offer(bob_, USD(10), eur(10)));
+            // bob creates a regular USD/EUR offer
+            auto const regularOfferSeq{env.seq(bob)};
+            env(offer(bob, USD(10), eur(10)));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, USD(10), eur(10)));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, USD(10), eur(10)));
 
-            // alice_ tries to pay again, but still fails because the regular
+            // alice tries to pay again, but still fails because the regular
             // offer cannot be consumed
-            env(pay(alice_, carol_, eur(10)),
+            env(pay(alice, carol, eur(10)),
                 Path(~USD, ~eur),
                 Sendmax(XRP(10)),
                 Domain(domainID),
                 Ter(tecPATH_PARTIAL));
             env.close();
 
-            // bob_ creates a domain USD/EUR offer
-            auto const eurOfferSeq{env.seq(bob_)};
-            env(offer(bob_, USD(10), eur(10)), Domain(domainID));
+            // bob creates a domain USD/EUR offer
+            auto const eurOfferSeq{env.seq(bob)};
+            env(offer(bob, USD(10), eur(10)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(10), eur(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(10), eur(10), 0, true));
 
-            // alice_ successfully consume two domain offers: xrp/usd and usd/eur
-            env(pay(alice_, carol_, eur(5)), Sendmax(XRP(5)), Domain(domainID), Path(~USD, ~eur));
+            // alice successfully consume two domain offers: xrp/usd and usd/eur
+            env(pay(alice, carol, eur(5)), Sendmax(XRP(5)), Domain(domainID), Path(~USD, ~eur));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(5), USD(5), 0, true));
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(5), eur(5), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(5), USD(5), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(5), eur(5), 0, true));
 
-            // alice_ successfully consume two domain offers and deletes them
+            // alice successfully consume two domain offers and deletes them
             // we compute path this time using `paths`
-            env(pay(alice_, carol_, eur(5)), Sendmax(XRP(5)), Domain(domainID), Paths(XRP));
+            env(pay(alice, carol, eur(5)), Sendmax(XRP(5)), Domain(domainID), Paths(XRP));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, bob_, usdOfferSeq));
-            BEAST_EXPECT(!offerExists(env, bob_, eurOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, usdOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, eurOfferSeq));
 
             // regular offer is not consumed
-            BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, USD(10), eur(10)));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, USD(10), eur(10)));
         }
 
         // domain payment cannot consume offer from another domain
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // Fund devin and create USD trustline
@@ -700,7 +700,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             auto const badCredType = "badCred";
@@ -720,24 +720,24 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // domain payment can't consume an offer from another domain
-            env(pay(alice_, carol_, USD(10)),
+            env(pay(alice, carol, USD(10)),
                 Path(~USD),
                 Sendmax(XRP(10)),
                 Domain(domainID),
                 Ter(tecPATH_PARTIAL));
             env.close();
 
-            // bob_ creates an offer under the right domain
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            // bob creates an offer under the right domain
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
 
             // domain payment now consumes from the right domain
-            env(pay(alice_, carol_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(alice, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
         }
 
         // sanity check: devin, who is part of the domain but doesn't have a
@@ -745,10 +745,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
             // fund devin but don't create a USD trustline with gateway
@@ -764,14 +764,14 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // successful payment because offer is consumed
-            env(pay(devin, alice_, USD(10)), Sendmax(XRP(10)), Domain(domainID));
+            env(pay(devin, alice, USD(10)), Sendmax(XRP(10)), Domain(domainID));
             env.close();
         }
 
         // offer becomes unfunded when offer owner's cred expires
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
@@ -780,7 +780,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
             env.trust(USD(1000), devin);
             env.close();
-            env(pay(gw_, devin, USD(100)));
+            env(pay(gw, devin, USD(100)));
             env.close();
 
             auto jv = credentials::create(devin, domainOwner, credType);
@@ -797,7 +797,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close();
 
             // devin's offer can still be consumed while his cred isn't expired
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
             env.close();
             BEAST_EXPECT(checkOffer(env, devin, offerSeq, XRP(5), USD(5), 0, true));
 
@@ -805,7 +805,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env.close(std::chrono::seconds(20));
 
             // devin's offer is unfunded now due to expired cred
-            env(pay(alice_, carol_, USD(5)),
+            env(pay(alice, carol, USD(5)),
                 Path(~USD),
                 Sendmax(XRP(5)),
                 Domain(domainID),
@@ -817,30 +817,30 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // offer becomes unfunded when offer owner's cred is removed
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const offerSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const offerSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            // bob_'s offer can still be consumed while his cred exists
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
+            // bob's offer can still be consumed while his cred exists
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, offerSeq, XRP(5), USD(5), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, offerSeq, XRP(5), USD(5), 0, true));
 
-            // remove bob_'s cred
-            env(credentials::deleteCred(domainOwner, bob_, domainOwner, credType));
+            // remove bob's cred
+            env(credentials::deleteCred(domainOwner, bob, domainOwner, credType));
             env.close();
 
-            // bob_'s offer is unfunded now due to expired cred
-            env(pay(alice_, carol_, USD(5)),
+            // bob's offer is unfunded now due to expired cred
+            env(pay(alice, carol, USD(5)),
                 Path(~USD),
                 Sendmax(XRP(5)),
                 Domain(domainID),
                 Ter(tecPATH_PARTIAL));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, offerSeq, XRP(5), USD(5), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, offerSeq, XRP(5), USD(5), 0, true));
         }
     }
 
@@ -853,34 +853,34 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // payment. If the domain wishes to control who is allowed to ripple
         // through, they should set the rippling individually
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
 
-        auto const eura = alice_["EUR"];
-        auto const eurb = bob_["EUR"];
+        auto const eura = alice["EUR"];
+        auto const eurb = bob["EUR"];
 
-        env.trust(eura(100), bob_);
-        env.trust(eurb(100), carol_);
+        env.trust(eura(100), bob);
+        env.trust(eurb(100), carol);
         env.close();
 
-        // remove bob_ from domain
-        env(credentials::deleteCred(domainOwner, bob_, domainOwner, credType));
+        // remove bob from domain
+        env(credentials::deleteCred(domainOwner, bob, domainOwner, credType));
         env.close();
 
-        // alice_ can still ripple through bob_ even though he's not part
+        // alice can still ripple through bob even though he's not part
         // of the domain, this is intentional
-        env(pay(alice_, carol_, eurb(10)), Paths(eura), Domain(domainID));
+        env(pay(alice, carol, eurb(10)), Paths(eura), Domain(domainID));
         env.close();
-        env.require(Balance(bob_, eura(10)), Balance(carol_, eurb(10)));
+        env.require(Balance(bob, eura(10)), Balance(carol, eurb(10)));
 
-        // carol_ sets no ripple on bob_
-        env(trust(carol_, bob_["EUR"](0), bob_, tfSetNoRipple));
+        // carol sets no ripple on bob
+        env(trust(carol, bob["EUR"](0), bob, tfSetNoRipple));
         env.close();
 
-        // payment no longer works because carol_ has no ripple on bob_
-        env(pay(alice_, carol_, eurb(5)), Paths(eura), Domain(domainID), Ter(tecPATH_DRY));
+        // payment no longer works because carol has no ripple on bob
+        env(pay(alice, carol, eurb(5)), Paths(eura), Domain(domainID), Ter(tecPATH_DRY));
         env.close();
-        env.require(Balance(bob_, eura(10)), Balance(carol_, eurb(10)));
+        env.require(Balance(bob, eura(10)), Balance(carol, eurb(10)));
     }
 
     void
@@ -891,37 +891,37 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // whether the issuer is in the domain should NOT affect whether an
         // offer can be consumed in domain payment
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
 
         // create an xrp/usd offer with usd as takergets
-        auto const bobOffer1Seq{env.seq(bob_)};
-        env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+        auto const bobOffer1Seq{env.seq(bob)};
+        env(offer(bob, XRP(10), USD(10)), Domain(domainID));
         env.close();
 
         // create an usd/xrp offer with usd as takerpays
-        auto const bobOffer2Seq{env.seq(bob_)};
-        env(offer(bob_, USD(10), XRP(10)), Domain(domainID), Txflags(tfPassive));
+        auto const bobOffer2Seq{env.seq(bob)};
+        env(offer(bob, USD(10), XRP(10)), Domain(domainID), Txflags(tfPassive));
         env.close();
 
-        BEAST_EXPECT(checkOffer(env, bob_, bobOffer1Seq, XRP(10), USD(10), 0, true));
-        BEAST_EXPECT(checkOffer(env, bob_, bobOffer2Seq, USD(10), XRP(10), lsfPassive, true));
+        BEAST_EXPECT(checkOffer(env, bob, bobOffer1Seq, XRP(10), USD(10), 0, true));
+        BEAST_EXPECT(checkOffer(env, bob, bobOffer2Seq, USD(10), XRP(10), lsfPassive, true));
 
         // remove gateway from domain
-        env(credentials::deleteCred(domainOwner, gw_, domainOwner, credType));
+        env(credentials::deleteCred(domainOwner, gw, domainOwner, credType));
         env.close();
 
         // payment succeeds even if issuer is not in domain
         // xrp/usd offer is consumed
-        env(pay(alice_, carol_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+        env(pay(alice, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
         env.close();
-        BEAST_EXPECT(!offerExists(env, bob_, bobOffer1Seq));
+        BEAST_EXPECT(!offerExists(env, bob, bobOffer1Seq));
 
         // payment succeeds even if issuer is not in domain
         // usd/xrp offer is consumed
-        env(pay(alice_, carol_, XRP(10)), Path(~XRP), Sendmax(USD(10)), Domain(domainID));
+        env(pay(alice, carol, XRP(10)), Path(~XRP), Sendmax(USD(10)), Domain(domainID));
         env.close();
-        BEAST_EXPECT(!offerExists(env, bob_, bobOffer2Seq));
+        BEAST_EXPECT(!offerExists(env, bob, bobOffer2Seq));
     }
 
     void
@@ -932,36 +932,36 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // checking that an unfunded offer will be implicitly removed by a
         // successful payment tx
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
 
-        auto const aliceOfferSeq{env.seq(alice_)};
-        env(offer(alice_, XRP(100), USD(100)), Domain(domainID));
+        auto const aliceOfferSeq{env.seq(alice)};
+        env(offer(alice, XRP(100), USD(100)), Domain(domainID));
         env.close();
 
-        auto const bobOfferSeq{env.seq(bob_)};
-        env(offer(bob_, XRP(20), USD(20)), Domain(domainID));
+        auto const bobOfferSeq{env.seq(bob)};
+        env(offer(bob, XRP(20), USD(20)), Domain(domainID));
         env.close();
 
-        BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(20), USD(20), 0, true));
-        BEAST_EXPECT(checkOffer(env, alice_, aliceOfferSeq, XRP(100), USD(100), 0, true));
+        BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(20), USD(20), 0, true));
+        BEAST_EXPECT(checkOffer(env, alice, aliceOfferSeq, XRP(100), USD(100), 0, true));
 
-        auto const domainDirKey = getDefaultOfferDirKey(env, bob_, bobOfferSeq);
+        auto const domainDirKey = getDefaultOfferDirKey(env, bob, bobOfferSeq);
         BEAST_EXPECT(domainDirKey);
         BEAST_EXPECT(checkDirectorySize(
             env, *domainDirKey, 2));  // NOLINT(bugprone-unchecked-optional-access)
 
-        // remove alice_ from domain and thus alice_'s offer becomes unfunded
-        env(credentials::deleteCred(domainOwner, alice_, domainOwner, credType));
+        // remove alice from domain and thus alice's offer becomes unfunded
+        env(credentials::deleteCred(domainOwner, alice, domainOwner, credType));
         env.close();
 
-        env(pay(gw_, carol_, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
+        env(pay(gw, carol, USD(10)), Path(~USD), Sendmax(XRP(10)), Domain(domainID));
         env.close();
 
-        BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
+        BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
 
-        // alice_'s unfunded offer is removed implicitly
-        BEAST_EXPECT(!offerExists(env, alice_, aliceOfferSeq));
+        // alice's unfunded offer is removed implicitly
+        BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
         BEAST_EXPECT(checkDirectorySize(
             env, *domainDirKey, 1));  // NOLINT(bugprone-unchecked-optional-access)
     }
@@ -972,12 +972,12 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         testcase("AMM not used");
 
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
-        AMM const amm(env, alice_, XRP(10), USD(50));
+        AMM const amm(env, alice, XRP(10), USD(50));
 
         // a domain payment isn't able to consume AMM
-        env(pay(bob_, carol_, USD(5)),
+        env(pay(bob, carol, USD(5)),
             Path(~USD),
             Sendmax(XRP(5)),
             Domain(domainID),
@@ -985,7 +985,7 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         env.close();
 
         // a non domain payment can use AMM
-        env(pay(bob_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)));
+        env(pay(bob, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
         env.close();
 
         // USD amount in AMM is changed
@@ -1001,126 +1001,126 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // test preflight - invalid hybrid flag
         {
             Env env(*this, features - featurePermissionedDEX);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            env(offer(bob_, XRP(10), USD(10)),
+            env(offer(bob, XRP(10), USD(10)),
                 Domain(domainID),
                 Txflags(tfHybrid),
                 Ter(temDISABLED));
             env.close();
 
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Ter(temINVALID_FLAG));
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Ter(temINVALID_FLAG));
             env.close();
 
             env.enableFeature(featurePermissionedDEX);
             env.close();
 
             // hybrid offer must have domainID
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Ter(temINVALID_FLAG));
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Ter(temINVALID_FLAG));
             env.close();
 
             // hybrid offer must have domainID
-            auto const offerSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            auto const offerSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, offerSeq, XRP(10), USD(10), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, offerSeq, XRP(10), USD(10), lsfHybrid, true));
         }
 
         // apply - domain offer can cross with hybrid
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
-            BEAST_EXPECT(offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, bob_) == 3);
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, bob) == 3);
 
-            auto const aliceOfferSeq{env.seq(alice_)};
-            env(offer(alice_, USD(10), XRP(10)), Domain(domainID));
+            auto const aliceOfferSeq{env.seq(alice)};
+            env(offer(alice, USD(10), XRP(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, alice_, aliceOfferSeq));
-            BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, alice_) == 2);
+            BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, alice) == 2);
         }
 
         // apply - open offer can cross with hybrid
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, bob_) == 3);
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, bob) == 3);
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
 
-            auto const aliceOfferSeq{env.seq(alice_)};
-            env(offer(alice_, USD(10), XRP(10)));
+            auto const aliceOfferSeq{env.seq(alice)};
+            env(offer(alice, USD(10), XRP(10)));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, alice_, aliceOfferSeq));
-            BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, alice_) == 2);
+            BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, alice) == 2);
         }
 
         // apply - by default, hybrid offer tries to cross with offers in the
         // domain book
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, true));
-            BEAST_EXPECT(ownerCount(env, bob_) == 3);
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(ownerCount(env, bob) == 3);
 
             // hybrid offer auto crosses with domain offer
-            auto const aliceOfferSeq{env.seq(alice_)};
-            env(offer(alice_, USD(10), XRP(10)), Domain(domainID), Txflags(tfHybrid));
+            auto const aliceOfferSeq{env.seq(alice)};
+            env(offer(alice, USD(10), XRP(10)), Domain(domainID), Txflags(tfHybrid));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, alice_, aliceOfferSeq));
-            BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(ownerCount(env, alice_) == 2);
+            BEAST_EXPECT(!offerExists(env, alice, aliceOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(ownerCount(env, alice) == 2);
         }
 
         // apply - hybrid offer does not automatically cross with open offers
         // because by default, it only tries to cross domain offers
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const bobOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)));
+            auto const bobOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, false));
-            BEAST_EXPECT(ownerCount(env, bob_) == 3);
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, false));
+            BEAST_EXPECT(ownerCount(env, bob) == 3);
 
             // hybrid offer auto crosses with domain offer
-            auto const aliceOfferSeq{env.seq(alice_)};
-            env(offer(alice_, USD(10), XRP(10)), Domain(domainID), Txflags(tfHybrid));
+            auto const aliceOfferSeq{env.seq(alice)};
+            env(offer(alice, USD(10), XRP(10)), Domain(domainID), Txflags(tfHybrid));
             env.close();
 
-            BEAST_EXPECT(offerExists(env, alice_, aliceOfferSeq));
-            BEAST_EXPECT(offerExists(env, bob_, bobOfferSeq));
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), 0, false));
-            BEAST_EXPECT(checkOffer(env, alice_, aliceOfferSeq, USD(10), XRP(10), lsfHybrid, true));
-            BEAST_EXPECT(ownerCount(env, alice_) == 3);
+            BEAST_EXPECT(offerExists(env, alice, aliceOfferSeq));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), 0, false));
+            BEAST_EXPECT(checkOffer(env, alice, aliceOfferSeq, USD(10), XRP(10), lsfHybrid, true));
+            BEAST_EXPECT(ownerCount(env, alice) == 3);
         }
     }
 
@@ -1129,58 +1129,97 @@ class PermissionedDEX_test : public beast::unit_test::Suite
     {
         testcase("Hybrid invalid offer");
 
-        // bob_ has a hybrid offer and then he is removed from domain.
-        // in this case, the hybrid offer will be considered as unfunded even in
-        // a regular payment
+        // bob has a hybrid offer and then he is removed from the domain.
+        // Domain payments must not consume the offer; regular open-book
+        // payments follow the fixCleanup3_3_0 behavior checked below.
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
 
-        auto const hybridOfferSeq{env.seq(bob_)};
-        env(offer(bob_, XRP(50), USD(50)), Txflags(tfHybrid), Domain(domainID));
+        auto const hybridOfferSeq{env.seq(bob)};
+        env(offer(bob, XRP(50), USD(50)), Txflags(tfHybrid), Domain(domainID));
         env.close();
 
-        // remove bob_ from domain
-        env(credentials::deleteCred(domainOwner, bob_, domainOwner, credType));
+        // remove bob from domain
+        env(credentials::deleteCred(domainOwner, bob, domainOwner, credType));
         env.close();
 
-        // bob_'s hybrid offer is unfunded and can not be consumed in a domain
+        // bob's hybrid offer is unfunded and can not be consumed in a domain
         // payment
-        env(pay(alice_, carol_, USD(5)),
+        env(pay(alice, carol, USD(5)),
             Path(~USD),
             Sendmax(XRP(5)),
             Domain(domainID),
             Ter(tecPATH_PARTIAL));
         env.close();
-        BEAST_EXPECT(checkOffer(env, bob_, hybridOfferSeq, XRP(50), USD(50), lsfHybrid, true));
+        BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(50), USD(50), lsfHybrid, true));
 
-        // bob_'s unfunded hybrid offer can't be consumed even with a regular
-        // payment
-        env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)), Ter(tecPATH_PARTIAL));
-        env.close();
-        BEAST_EXPECT(checkOffer(env, bob_, hybridOfferSeq, XRP(50), USD(50), lsfHybrid, true));
+        if (features[fixCleanup3_3_0])
+        {
+            // Post-fixCleanup3_3_0: hybrid offer can still be consumed via a regular
+            // open-book payment even though the domain credential was revoked.
+            auto const carolBalBefore = env.balance(carol, USD);
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
+            env.close();
+            BEAST_EXPECT(env.balance(carol, USD) - carolBalBefore == USD(5));
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(45), USD(45), lsfHybrid, true));
 
-        // create a regular offer
-        auto const regularOfferSeq{env.seq(bob_)};
-        env(offer(bob_, XRP(10), USD(10)));
-        env.close();
-        BEAST_EXPECT(offerExists(env, bob_, regularOfferSeq));
-        BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, XRP(10), USD(10)));
+            // create a regular offer alongside the hybrid one
+            auto const regularOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)));
+            env.close();
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
 
-        auto const sleHybridOffer = env.le(keylet::offer(bob_.id(), hybridOfferSeq));
-        BEAST_EXPECT(sleHybridOffer);
-        auto const openDir =
-            sleHybridOffer->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory);
-        BEAST_EXPECT(checkDirectorySize(env, openDir, 2));
+            auto const sleHybridOffer = env.le(keylet::offer(bob.id(), hybridOfferSeq));
+            if (!BEAST_EXPECT(sleHybridOffer))
+                return;
+            auto const openDir =
+                sleHybridOffer->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory);
+            // both offers are in the open book directory
+            BEAST_EXPECT(checkDirectorySize(env, openDir, 2));
 
-        // this normal payment should consume the regular offer and remove the
-        // unfunded hybrid offer
-        env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)));
-        env.close();
+            // A regular payment crosses the hybrid offer first (FIFO, older
+            // offer), then stops; the regular offer is untouched.
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
+            env.close();
 
-        BEAST_EXPECT(!offerExists(env, bob_, hybridOfferSeq));
-        BEAST_EXPECT(checkOffer(env, bob_, regularOfferSeq, XRP(5), USD(5)));
-        BEAST_EXPECT(checkDirectorySize(env, openDir, 1));
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(40), USD(40), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
+            BEAST_EXPECT(checkDirectorySize(env, openDir, 2));
+        }
+        else
+        {
+            // Pre-fixCleanup3_3_0: the open-book traversal
+            // also runs the offerInDomain eviction check, so the hybrid offer
+            // is treated as unfunded and the regular payment fails.
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)), Ter(tecPATH_PARTIAL));
+            env.close();
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(50), USD(50), lsfHybrid, true));
+
+            // create a regular offer
+            auto const regularOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)));
+            env.close();
+            BEAST_EXPECT(offerExists(env, bob, regularOfferSeq));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(10), USD(10)));
+
+            auto const sleHybridOffer = env.le(keylet::offer(bob.id(), hybridOfferSeq));
+            if (!BEAST_EXPECT(sleHybridOffer))
+                return;
+            auto const openDir =
+                sleHybridOffer->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory);
+            BEAST_EXPECT(checkDirectorySize(env, openDir, 2));
+
+            // This payment crosses the regular offer and permanently evicts the
+            // hybrid offer from the open book (since the payment succeeds, the
+            // sandbox, including the hybrid eviction, is committed).
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
+            env.close();
+
+            BEAST_EXPECT(!offerExists(env, bob, hybridOfferSeq));
+            BEAST_EXPECT(checkOffer(env, bob, regularOfferSeq, XRP(5), USD(5)));
+            BEAST_EXPECT(checkDirectorySize(env, openDir, 1));
+        }
     }
 
     void
@@ -1191,29 +1230,29 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         // both non domain and domain payments can consume hybrid offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const hybridOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            auto const hybridOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
 
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, hybridOfferSeq, XRP(5), USD(5), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(5), USD(5), lsfHybrid, true));
 
-            // hybrid offer can't be consumed since bob_ is not in domain anymore
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)));
+            // hybrid offer can't be consumed since bob is not in domain anymore
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, bob_, hybridOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, hybridOfferSeq));
         }
 
         // someone from another domain can't cross hybrid if they specified
         // wrong domainID
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
             // Fund accounts
@@ -1235,8 +1274,8 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             env(credentials::accept(devin, badDomainOwner, badCredType));
             env.close();
 
-            auto const hybridOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            auto const hybridOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
 
             // other domains can't consume the offer
@@ -1246,107 +1285,197 @@ class PermissionedDEX_test : public beast::unit_test::Suite
                 Domain(badDomainID),
                 Ter(tecPATH_DRY));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, hybridOfferSeq, XRP(10), USD(10), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(10), USD(10), lsfHybrid, true));
 
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)), Domain(domainID));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, hybridOfferSeq, XRP(5), USD(5), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, hybridOfferSeq, XRP(5), USD(5), lsfHybrid, true));
 
-            // hybrid offer can't be consumed since bob_ is not in domain anymore
-            env(pay(alice_, carol_, USD(5)), Path(~USD), Sendmax(XRP(5)));
+            // hybrid offer can't be consumed since bob is not in domain anymore
+            env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
             env.close();
 
-            BEAST_EXPECT(!offerExists(env, bob_, hybridOfferSeq));
+            BEAST_EXPECT(!offerExists(env, bob, hybridOfferSeq));
         }
 
         // test domain payment consuming two offers w/ hybrid offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const eur = gw_["EUR"];
-            env.trust(eur(1000), alice_);
+            auto const eur = gw["EUR"];
+            env.trust(eur(1000), alice);
             env.close();
-            env.trust(eur(1000), bob_);
+            env.trust(eur(1000), bob);
             env.close();
-            env.trust(eur(1000), carol_);
+            env.trust(eur(1000), carol);
             env.close();
-            env(pay(gw_, bob_, eur(100)));
+            env(pay(gw, bob, eur(100)));
             env.close();
 
-            auto const usdOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)), Domain(domainID));
+            auto const usdOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(10), USD(10), 0, true));
 
             // payment fail because there isn't eur offer
-            env(pay(alice_, carol_, eur(5)),
+            env(pay(alice, carol, eur(5)),
                 Path(~USD, ~eur),
                 Sendmax(XRP(5)),
                 Domain(domainID),
                 Ter(tecPATH_PARTIAL));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(10), USD(10), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(10), USD(10), 0, true));
 
-            // bob_ creates a hybrid eur offer
-            auto const eurOfferSeq{env.seq(bob_)};
-            env(offer(bob_, USD(10), eur(10)), Domain(domainID), Txflags(tfHybrid));
+            // bob creates a hybrid eur offer
+            auto const eurOfferSeq{env.seq(bob)};
+            env(offer(bob, USD(10), eur(10)), Domain(domainID), Txflags(tfHybrid));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(10), eur(10), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(10), eur(10), lsfHybrid, true));
 
-            // alice_ successfully consume two domain offers: xrp/usd and usd/eur
-            env(pay(alice_, carol_, eur(5)), Path(~USD, ~eur), Sendmax(XRP(5)), Domain(domainID));
+            // alice successfully consume two domain offers: xrp/usd and usd/eur
+            env(pay(alice, carol, eur(5)), Path(~USD, ~eur), Sendmax(XRP(5)), Domain(domainID));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(5), USD(5), 0, true));
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(5), eur(5), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(5), USD(5), 0, true));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(5), eur(5), lsfHybrid, true));
         }
 
         // test regular payment using a regular offer and a hybrid offer
         {
             Env env(*this, features);
-            auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
                 PermissionedDEX(env);
 
-            auto const eur = gw_["EUR"];
-            env.trust(eur(1000), alice_);
+            auto const eur = gw["EUR"];
+            env.trust(eur(1000), alice);
             env.close();
-            env.trust(eur(1000), bob_);
+            env.trust(eur(1000), bob);
             env.close();
-            env.trust(eur(1000), carol_);
+            env.trust(eur(1000), carol);
             env.close();
-            env(pay(gw_, bob_, eur(100)));
+            env(pay(gw, bob, eur(100)));
             env.close();
 
-            // bob_ creates a regular usd offer
-            auto const usdOfferSeq{env.seq(bob_)};
-            env(offer(bob_, XRP(10), USD(10)));
+            // bob creates a regular usd offer
+            auto const usdOfferSeq{env.seq(bob)};
+            env(offer(bob, XRP(10), USD(10)));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(10), USD(10), 0, false));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(10), USD(10), 0, false));
 
-            // bob_ creates a hybrid eur offer
-            auto const eurOfferSeq{env.seq(bob_)};
-            env(offer(bob_, USD(10), eur(10)), Domain(domainID), Txflags(tfHybrid));
+            // bob creates a hybrid eur offer
+            auto const eurOfferSeq{env.seq(bob)};
+            env(offer(bob, USD(10), eur(10)), Domain(domainID), Txflags(tfHybrid));
             env.close();
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(10), eur(10), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(10), eur(10), lsfHybrid, true));
 
-            // alice_ successfully consume two offers: xrp/usd and usd/eur
-            env(pay(alice_, carol_, eur(5)), Path(~USD, ~eur), Sendmax(XRP(5)));
+            // alice successfully consume two offers: xrp/usd and usd/eur
+            env(pay(alice, carol, eur(5)), Path(~USD, ~eur), Sendmax(XRP(5)));
             env.close();
 
-            BEAST_EXPECT(checkOffer(env, bob_, usdOfferSeq, XRP(5), USD(5), 0, false));
-            BEAST_EXPECT(checkOffer(env, bob_, eurOfferSeq, USD(5), eur(5), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, usdOfferSeq, XRP(5), USD(5), 0, false));
+            BEAST_EXPECT(checkOffer(env, bob, eurOfferSeq, USD(5), eur(5), lsfHybrid, true));
         }
     }
 
+    // Test that a hybrid offer remains crossable in the open book after the
+    // owner's domain credential expires. A domain payment after expiry should
+    // fail (domain book evicts the offer in its sandbox), but the open book
+    // remains usable.
+    void
+    testHybridOpenBookAfterCredentialExpiry(FeatureBitset features)
+    {
+        testcase("Hybrid open book after credential expiry");
+
+        Env env(*this, features);
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+            PermissionedDEX(env);
+
+        Account const devin("devin");
+        env.fund(XRP(100000), devin);
+        env.close();
+        env.trust(USD(1000), devin);
+        env.close();
+        env(pay(gw, devin, USD(100)));
+        env.close();
+
+        // Give devin a credential that expires far enough in the future to
+        // survive the setup env.close() calls.
+        auto jv = credentials::create(devin, domainOwner, credType);
+        uint32_t const t = env.current()->header().parentCloseTime.time_since_epoch().count();
+        jv[sfExpiration.jsonName] = t + 100;
+        env(jv);
+        env.close();
+        env(credentials::accept(devin, domainOwner, credType));
+        env.close();
+
+        // Devin creates a hybrid offer: sell USD(10) for XRP(10).
+        // The offer is placed in both the domain book and the open book.
+        auto const hybridOfferSeq{env.seq(devin)};
+        env(offer(devin, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+        env.close();
+
+        BEAST_EXPECT(checkOffer(env, devin, hybridOfferSeq, XRP(10), USD(10), lsfHybrid, true));
+
+        // A non-domain open-book payment partially crosses the offer while
+        // devin's credential is still valid.
+        auto carolBalance = env.balance(carol, USD);
+        env(pay(alice, carol, USD(5)), Path(~USD), Sendmax(XRP(5)));
+        env.close();
+        BEAST_EXPECT(env.balance(carol, USD) - carolBalance == USD(5));
+        BEAST_EXPECT(checkOffer(env, devin, hybridOfferSeq, XRP(5), USD(5), lsfHybrid, true));
+
+        // Advance time so that devin's credential expires.
+        env.close(std::chrono::seconds(100));
+
+        // Confirm devin can no longer create domain offers.
+        env(offer(devin, XRP(1), USD(1)), Domain(domainID), Ter(tecNO_PERMISSION));
+        env.close();
+
+        // The hybrid offer must still exist in the open book after expiry.
+        BEAST_EXPECT(offerExists(env, devin, hybridOfferSeq));
+
+        // A non-domain open-book payment must cross (not evict) the
+        // remaining portion of devin's hybrid offer.
+        carolBalance = env.balance(carol, USD);
+        env(pay(alice, carol, USD(2)), Path(~USD), Sendmax(XRP(2)));
+        env.close();
+
+        // Carol received USD; the offer was crossed, not evicted.
+        BEAST_EXPECT(env.balance(carol, USD) - carolBalance == USD(2));
+        // Offer still exists with 3 USD / 3 XRP remaining.
+        BEAST_EXPECT(checkOffer(env, devin, hybridOfferSeq, XRP(3), USD(3), lsfHybrid, true));
+
+        // A domain payment now fails because the domain book evicts devin's
+        // offer (his credential has expired).  The eviction is rolled back with
+        // the failed sandbox, so the offer is NOT permanently removed.
+        env(pay(alice, carol, USD(1)),
+            Path(~USD),
+            Sendmax(XRP(1)),
+            Domain(domainID),
+            Ter(tecPATH_PARTIAL));
+        env.close();
+
+        // Offer still intact in the open book; domain payment did not
+        // permanently delete it.
+        BEAST_EXPECT(checkOffer(env, devin, hybridOfferSeq, XRP(3), USD(3), lsfHybrid, true));
+
+        // The open book can still fully consume the remaining portion.
+        carolBalance = env.balance(carol, USD);
+        env(pay(alice, carol, USD(3)), Path(~USD), Sendmax(XRP(3)));
+        env.close();
+        BEAST_EXPECT(env.balance(carol, USD) - carolBalance == USD(3));
+        BEAST_EXPECT(!offerExists(env, devin, hybridOfferSeq));
+    }
+
     void
     testHybridOfferDirectories(FeatureBitset features)
     {
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
 
         std::vector<std::uint32_t> offerSeqs;
@@ -1362,12 +1491,12 @@ class PermissionedDEX_test : public beast::unit_test::Suite
 
         for (size_t i = 1; i <= dirCnt; i++)
         {
-            auto const bobOfferSeq{env.seq(bob_)};
+            auto const bobOfferSeq{env.seq(bob)};
             offerSeqs.emplace_back(bobOfferSeq);
-            env(offer(bob_, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
+            env(offer(bob, XRP(10), USD(10)), Txflags(tfHybrid), Domain(domainID));
             env.close();
 
-            auto const sleOffer = env.le(keylet::offer(bob_.id(), bobOfferSeq));
+            auto const sleOffer = env.le(keylet::offer(bob.id(), bobOfferSeq));
             BEAST_EXPECT(sleOffer);
             BEAST_EXPECT(sleOffer->getFieldH256(sfBookDirectory) == domainDir);
             BEAST_EXPECT(sleOffer->getFieldArray(sfAdditionalBooks).size() == 1);
@@ -1375,17 +1504,17 @@ class PermissionedDEX_test : public beast::unit_test::Suite
                 sleOffer->getFieldArray(sfAdditionalBooks)[0].getFieldH256(sfBookDirectory) ==
                 openDir);
 
-            BEAST_EXPECT(checkOffer(env, bob_, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
+            BEAST_EXPECT(checkOffer(env, bob, bobOfferSeq, XRP(10), USD(10), lsfHybrid, true));
             BEAST_EXPECT(checkDirectorySize(env, domainDir, i));
             BEAST_EXPECT(checkDirectorySize(env, openDir, i));
         }
 
         for (auto const offerSeq : offerSeqs)
         {
-            env(offerCancel(bob_, offerSeq));
+            env(offerCancel(bob, offerSeq));
             env.close();
             dirCnt--;
-            BEAST_EXPECT(!offerExists(env, bob_, offerSeq));
+            BEAST_EXPECT(!offerExists(env, bob, offerSeq));
             BEAST_EXPECT(checkDirectorySize(env, domainDir, dirCnt));
             BEAST_EXPECT(checkDirectorySize(env, openDir, dirCnt));
         }
@@ -1397,34 +1526,34 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         testcase("Auto bridge");
 
         Env env(*this, features);
-        auto const& [gw_, domainOwner, alice_, bob_, carol_, USD, domainID, credType] =
+        auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
-        auto const eur = gw_["EUR"];
+        auto const eur = gw["EUR"];
 
-        for (auto const& account : {alice_, bob_, carol_})
+        for (auto const& account : {alice, bob, carol})
         {
             env(trust(account, eur(10000)));
             env.close();
         }
 
-        env(pay(gw_, carol_, eur(1)));
+        env(pay(gw, carol, eur(1)));
         env.close();
 
-        auto const aliceOfferSeq{env.seq(alice_)};
-        auto const bobOfferSeq{env.seq(bob_)};
-        env(offer(alice_, XRP(100), USD(1)), Domain(domainID));
-        env(offer(bob_, eur(1), XRP(100)), Domain(domainID));
+        auto const aliceOfferSeq{env.seq(alice)};
+        auto const bobOfferSeq{env.seq(bob)};
+        env(offer(alice, XRP(100), USD(1)), Domain(domainID));
+        env(offer(bob, eur(1), XRP(100)), Domain(domainID));
         env.close();
 
-        // carol_'s offer should cross bob_ and alice_'s offers due to auto
+        // carol's offer should cross bob and alice's offers due to auto
         // bridging
-        auto const carolOfferSeq{env.seq(carol_)};
-        env(offer(carol_, USD(1), eur(1)), Domain(domainID));
+        auto const carolOfferSeq{env.seq(carol)};
+        env(offer(carol, USD(1), eur(1)), Domain(domainID));
         env.close();
 
-        BEAST_EXPECT(!offerExists(env, bob_, aliceOfferSeq));
-        BEAST_EXPECT(!offerExists(env, bob_, bobOfferSeq));
-        BEAST_EXPECT(!offerExists(env, bob_, carolOfferSeq));
+        BEAST_EXPECT(!offerExists(env, bob, aliceOfferSeq));
+        BEAST_EXPECT(!offerExists(env, bob, bobOfferSeq));
+        BEAST_EXPECT(!offerExists(env, bob, carolOfferSeq));
     }
 
     void
@@ -1819,7 +1948,9 @@ public:
         // Test hybrid offers
         testHybridOfferCreate(all);
         testHybridBookStep(all);
+        testHybridInvalidOffer(all - fixCleanup3_3_0);
         testHybridInvalidOffer(all);
+        testHybridOpenBookAfterCredentialExpiry(all);
         testHybridOfferDirectories(all);
         testHybridMalformedOffer(all);
         testHybridMalformedOffer(all - fixCleanup3_1_3);