SERVER-38810 Use Session's concurrency control rules instead of internal mutexes in TransactionParticipant

This type simplifies and clarifies concurrency control in TransactionParticipant by:

(1) Removing TP's own mutexes and using the Session concurrency control rules,
instead. That is, certain state is only accessible when the Session is checked
out, and requires no further locking. Other state is observable either while
holding the client lock or while having checked out the Session. The latter type
of state is modifiable only when having checked out the session and locked the
client.

(2) Separating the two types of state in (1) into separate sub-structures in
TransactionParticipant, to make it clear who can access what state,

(3) Putting all methods formerly on TransactionParticipant onto new member
classes, TransactionParticipant::Participant and
TransactionParticipant::Observer. The latter can only read the observable state
from (1) above, and the participant may read or modify all of the state.

The two types introduced by (3) are designed to enforce proper concurrency
control by limiting access of their methods to the underlying
TransactionParticipant member variables. The observer type has a private o()
method which its other methods are required by convention to use in order to
obtain read-only access to the Observable state of the
TransactionParticipant. The participant type has the o() method plus an
o(WithLock) method that allows mutation of the state while holding the client
lock, and a p() method which allows reading and writing of the private state
with no other locks. Please see the implementation in
transaction_participant.cpp for examples.

It is worth noting that with this change, locking the Client is not needed often
and never for long, and there is no need for separate mutexes for participant
state and monitoring state.

1 files changed, 556 insertions, 890 deletions

diff --git a/src/mongo/db/transaction_participant_test.cpp b/src/mongo/db/transaction_participant_test.cpp
index d13a172d746..75e6ddafbad 100644
--- a/src/mongo/db/transaction_participant_test.cpp
+++ b/src/mongo/db/transaction_participant_test.cpp
@@ -234,24 +234,10 @@ protected:
     }
 
     void runFunctionFromDifferentOpCtx(std::function<void(OperationContext*)> func) {
-        // Stash the original client.
-        auto originalClient = Client::releaseCurrent();
-
         // Create a new client (e.g. for migration) and opCtx.
-        auto service = opCtx()->getServiceContext();
-        auto newClientOwned = service->makeClient("newClient");
-        auto newClient = newClientOwned.get();
-        Client::setCurrent(std::move(newClientOwned));
-        auto newOpCtx = newClient->makeOperationContext();
-
-        ON_BLOCK_EXIT([&] {
-            // Restore the original client.
-            newOpCtx.reset();
-            Client::releaseCurrent();
-            Client::setCurrent(std::move(originalClient));
-        });
-
-        // Run the function on bahalf of another operation context.
+        auto newClientOwned = getServiceContext()->makeClient("newClient");
+        AlternativeClientRegion acr(newClientOwned);
+        auto newOpCtx = cc().makeOperationContext();
         func(newOpCtx.get());
     }
 
@@ -260,7 +246,7 @@ protected:
         opCtx()->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
         auto opCtxSession = std::make_unique<MongoDOperationContextSession>(opCtx());
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, startNewTxn);
+        txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, startNewTxn);
         return opCtxSession;
     }
 
@@ -276,10 +262,10 @@ TEST_F(TxnParticipantTest, TransactionThrowsLockTimeoutIfLockIsUnavailable) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     { Lock::DBLock dbXLock(opCtx(), dbName, MODE_X); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     auto clientWithDatabaseXLock = Client::releaseCurrent();
 
 
@@ -305,8 +291,8 @@ TEST_F(TxnParticipantTest, TransactionThrowsLockTimeoutIfLockIsUnavailable) {
 
         MongoDOperationContextSession newOpCtxSession(newOpCtx.get());
         auto newTxnParticipant = TransactionParticipant::get(newOpCtx.get());
-        newTxnParticipant->beginOrContinue(newTxnNum, false, true);
-        newTxnParticipant->unstashTransactionResources(newOpCtx.get(), "insert");
+        newTxnParticipant.beginOrContinue(newOpCtx.get(), newTxnNum, false, true);
+        newTxnParticipant.unstashTransactionResources(newOpCtx.get(), "insert");
 
         Date_t t1 = Date_t::now();
         ASSERT_THROWS_CODE(Lock::DBLock(newOpCtx.get(), dbName, MODE_X),
@@ -342,14 +328,14 @@ TEST_F(TxnParticipantTest, StashAndUnstashResources) {
 
     // Perform initial unstash which sets up a WriteUnitOfWork.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
     ASSERT_EQUALS(originalLocker, opCtx()->lockState());
     ASSERT_EQUALS(originalRecoveryUnit, opCtx()->recoveryUnit());
     ASSERT(opCtx()->getWriteUnitOfWork());
     ASSERT(opCtx()->lockState()->isLocked());
 
     // Stash resources. The original Locker and RecoveryUnit now belong to the stash.
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_NOT_EQUALS(originalLocker, opCtx()->lockState());
     ASSERT_NOT_EQUALS(originalRecoveryUnit, opCtx()->recoveryUnit());
     ASSERT(!opCtx()->getWriteUnitOfWork());
@@ -359,25 +345,26 @@ TEST_F(TxnParticipantTest, StashAndUnstashResources) {
 
     // Unstash the stashed resources. This restores the original Locker and RecoveryUnit to the
     // OperationContext.
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
     ASSERT_EQUALS(originalLocker, opCtx()->lockState());
     ASSERT_EQUALS(originalRecoveryUnit, opCtx()->recoveryUnit());
     ASSERT(opCtx()->getWriteUnitOfWork());
 
     // Commit the transaction. This allows us to release locks.
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 }
 
 TEST_F(TxnParticipantTest, CannotSpecifyStartTransactionOnInProgressTxn) {
     // Must specify startTransaction=true and autocommit=false to start a transaction.
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    ASSERT_TRUE(txnParticipant->inMultiDocumentTransaction());
+    ASSERT_TRUE(txnParticipant.inMultiDocumentTransaction());
 
     // Cannot try to start a transaction that already started.
-    ASSERT_THROWS_CODE(txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, true),
-                       AssertionException,
-                       ErrorCodes::ConflictingOperationInProgress);
+    ASSERT_THROWS_CODE(
+        txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, true),
+        AssertionException,
+        ErrorCodes::ConflictingOperationInProgress);
 }
 
 TEST_F(TxnParticipantTest, AutocommitRequiredOnEveryTxnOp) {
@@ -385,19 +372,19 @@ TEST_F(TxnParticipantTest, AutocommitRequiredOnEveryTxnOp) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // We must have stashed transaction resources to do a second operation on the transaction.
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     auto txnNum = *opCtx()->getTxnNumber();
     // Omitting 'autocommit' after the first statement of a transaction should throw an error.
-    ASSERT_THROWS_CODE(txnParticipant->beginOrContinue(txnNum, boost::none, boost::none),
+    ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(opCtx(), txnNum, boost::none, boost::none),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 
     // Including autocommit=false should succeed.
-    txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, boost::none);
+    txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, boost::none);
 }
 
 DEATH_TEST_F(TxnParticipantTest, AutocommitCannotBeTrue, "invariant") {
@@ -405,7 +392,7 @@ DEATH_TEST_F(TxnParticipantTest, AutocommitCannotBeTrue, "invariant") {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Passing 'autocommit=true' is not allowed and should crash.
-    txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), true, boost::none);
+    txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), true, boost::none);
 }
 
 DEATH_TEST_F(TxnParticipantTest, StartTransactionCannotBeFalse, "invariant") {
@@ -413,7 +400,7 @@ DEATH_TEST_F(TxnParticipantTest, StartTransactionCannotBeFalse, "invariant") {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Passing 'startTransaction=false' is not allowed and should crash.
-    txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, false);
+    txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, false);
 }
 
 TEST_F(TxnParticipantTest, SameTransactionPreservesStoredStatements) {
@@ -421,40 +408,40 @@ TEST_F(TxnParticipantTest, SameTransactionPreservesStoredStatements) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // We must have stashed transaction resources to re-open the transaction.
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
     ASSERT_BSONOBJ_EQ(operation.toBSON(),
-                      txnParticipant->getTransactionOperationsForTest()[0].toBSON());
+                      txnParticipant.getTransactionOperationsForTest()[0].toBSON());
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     // Check the transaction operations before re-opening the transaction.
     ASSERT_BSONOBJ_EQ(operation.toBSON(),
-                      txnParticipant->getTransactionOperationsForTest()[0].toBSON());
+                      txnParticipant.getTransactionOperationsForTest()[0].toBSON());
 
     // Re-opening the same transaction should have no effect.
-    txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, boost::none);
+    txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, boost::none);
     ASSERT_BSONOBJ_EQ(operation.toBSON(),
-                      txnParticipant->getTransactionOperationsForTest()[0].toBSON());
+                      txnParticipant.getTransactionOperationsForTest()[0].toBSON());
 }
 
 TEST_F(TxnParticipantTest, AbortClearsStoredStatements) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
     ASSERT_BSONOBJ_EQ(operation.toBSON(),
-                      txnParticipant->getTransactionOperationsForTest()[0].toBSON());
+                      txnParticipant.getTransactionOperationsForTest()[0].toBSON());
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT_TRUE(txnParticipant->getTransactionOperationsForTest().empty());
-    ASSERT_TRUE(txnParticipant->transactionIsAborted());
+    txnParticipant.stashTransactionResources(opCtx());
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT_TRUE(txnParticipant.getTransactionOperationsForTest().empty());
+    ASSERT_TRUE(txnParticipant.transactionIsAborted());
 }
 
 // This test makes sure the commit machinery works even when no operations are done on the
@@ -462,14 +449,14 @@ TEST_F(TxnParticipantTest, AbortClearsStoredStatements) {
 TEST_F(TxnParticipantTest, EmptyTransactionCommit) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->commitUnpreparedTransaction(opCtx());
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
 }
 
 // This test makes sure the commit machinery works even when no operations are done on the
@@ -477,45 +464,45 @@ TEST_F(TxnParticipantTest, EmptyTransactionCommit) {
 TEST_F(TxnParticipantTest, EmptyPreparedTransactionCommit) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.stashTransactionResources(opCtx());
 
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
 }
 
 TEST_F(TxnParticipantTest, PrepareSucceedsWithNestedLocks) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     {
         Lock::GlobalLock lk1(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
         Lock::GlobalLock lk2(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
     }
 
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.stashTransactionResources(opCtx());
 
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
 }
 
 TEST_F(TxnParticipantTest, CommitTransactionSetsCommitTimestampOnPreparedTransaction) {
     auto sessionCheckout = checkOutSession();
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     auto originalFn = _opObserver->onTransactionCommitFn;
@@ -531,13 +518,13 @@ TEST_F(TxnParticipantTest, CommitTransactionSetsCommitTimestampOnPreparedTransac
         ASSERT(statements.empty());
     };
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
 
     // The recovery unit is reset on commit.
     ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
 
-    txnParticipant->stashTransactionResources(opCtx());
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    txnParticipant.stashTransactionResources(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
     ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
 }
 
@@ -546,11 +533,11 @@ TEST_F(TxnParticipantTest, CommitTransactionWithCommitTimestampFailsOnUnprepared
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {}),
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {}),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 }
@@ -570,16 +557,16 @@ TEST_F(TxnParticipantTest, CommitTransactionDoesNotSetCommitTimestampOnUnprepare
     };
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
 
-    txnParticipant->stashTransactionResources(opCtx());
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    txnParticipant.stashTransactionResources(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
     ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
 }
 
@@ -587,12 +574,12 @@ TEST_F(TxnParticipantTest, CommitTransactionWithoutCommitTimestampFailsOnPrepare
     auto sessionCheckout = checkOutSession();
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    txnParticipant->prepareTransaction(opCtx(), {});
-    ASSERT_THROWS_CODE(txnParticipant->commitUnpreparedTransaction(opCtx()),
+    txnParticipant.prepareTransaction(opCtx(), {});
+    ASSERT_THROWS_CODE(txnParticipant.commitUnpreparedTransaction(opCtx()),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 }
@@ -601,12 +588,12 @@ TEST_F(TxnParticipantTest, CommitTransactionWithNullCommitTimestampFailsOnPrepar
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    txnParticipant->prepareTransaction(opCtx(), {});
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(opCtx(), Timestamp(), {}),
+    txnParticipant.prepareTransaction(opCtx(), {});
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(opCtx(), Timestamp(), {}),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 }
@@ -616,12 +603,12 @@ TEST_F(TxnParticipantTest,
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(
                            opCtx(), Timestamp(prepareTimestamp.getSecs() - 1, 1), {}),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
@@ -632,12 +619,12 @@ TEST_F(TxnParticipantTest,
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(opCtx(), prepareTimestamp, {}),
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(opCtx(), prepareTimestamp, {}),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 }
@@ -647,13 +634,13 @@ TEST_F(TxnParticipantTest,
 TEST_F(TxnParticipantTest, EmptyTransactionAbort) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT_TRUE(txnParticipant->transactionIsAborted());
+    txnParticipant.stashTransactionResources(opCtx());
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsAborted());
 }
 
 // This test makes sure the abort machinery works even when no operations are done on the
@@ -661,174 +648,20 @@ TEST_F(TxnParticipantTest, EmptyTransactionAbort) {
 TEST_F(TxnParticipantTest, EmptyPreparedTransactionAbort) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->prepareTransaction(opCtx(), {});
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT_TRUE(txnParticipant->transactionIsAborted());
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfUnstashAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // An unstash after an abort should uassert.
-    ASSERT_THROWS_CODE(txnParticipant->unstashTransactionResources(opCtx(), "find"),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfStashAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
-
-    // The transaction may be aborted without checking out the txnParticipant->
-    txnParticipant->abortArbitraryTransaction();
-
-    // A stash after an abort should be a noop.
-    txnParticipant->stashTransactionResources(opCtx());
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfAddTransactionOperationAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // An addTransactionOperation() after an abort should uassert.
-    auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    ASSERT_THROWS_CODE(txnParticipant->addTransactionOperation(opCtx(), operation),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfRetrieveCompletedTransactionOperationsAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // A retrieveCompletedTransactionOperations() after an abort should uassert.
-    ASSERT_THROWS_CODE(txnParticipant->retrieveCompletedTransactionOperations(opCtx()),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfClearOperationsInMemory) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // An clearOperationsInMemory() after an abort should uassert.
-    ASSERT_THROWS_CODE(txnParticipant->clearOperationsInMemory(opCtx()),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfCommitUnpreparedTransactionAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // A commitUnpreparedTransaction() after an abort should uassert.
-    ASSERT_THROWS_CODE(txnParticipant->commitUnpreparedTransaction(opCtx()),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfCommitPreparedTransactionAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    auto prepareTS = txnParticipant->prepareTransaction(opCtx(), {});
-    auto commitTS = Timestamp(prepareTS.getSecs(), prepareTS.getInc() + 1);
-
-    txnParticipant->abortArbitraryTransaction();
-
-    // A commitPreparedTransaction() after an abort should succeed since the abort should fail.
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
-
-    ASSERT(_opObserver->transactionCommitted);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    ASSERT(txnParticipant->transactionIsCommitted());
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfActiveUnpreparedAbortAndArbitraryAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-    ASSERT(txnParticipant->inMultiDocumentTransaction());
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // The operation throws for some reason and aborts implicitly.
-    // Abort active transaction after it's been aborted by KillSession is a no-op.
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
-    ASSERT(opCtx()->getWriteUnitOfWork() == nullptr);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfActivePreparedAbortAndArbitraryAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-    ASSERT(txnParticipant->inMultiDocumentTransaction());
-    txnParticipant->prepareTransaction(opCtx(), {});
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-
-    // The operation throws for some reason and aborts implicitly.
-    // Abort active transaction after it's been aborted by KillSession is a no-op.
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
-    ASSERT(opCtx()->getWriteUnitOfWork() == nullptr);
-}
-
-TEST_F(TxnParticipantTest, ConcurrencyOfPrepareTransactionAndAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-
-    // The transaction may be aborted without checking out the txnParticipant.
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT(txnParticipant->transactionIsAborted());
-
-    // A prepareTransaction() after an abort should uassert.
-    ASSERT_THROWS_CODE(txnParticipant->prepareTransaction(opCtx(), {}),
-                       AssertionException,
-                       ErrorCodes::NoSuchTransaction);
-    ASSERT_FALSE(_opObserver->transactionPrepared);
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.prepareTransaction(opCtx(), {});
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, KillSessionsDuringPrepareDoesNotAbortTransaction) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
     auto ruPrepareTimestamp = Timestamp();
     auto originalFn = _opObserver->onTransactionPrepareFn;
@@ -839,93 +672,41 @@ TEST_F(TxnParticipantTest, KillSessionsDuringPrepareDoesNotAbortTransaction) {
         ASSERT_FALSE(ruPrepareTimestamp.isNull());
 
         // The transaction may be aborted without checking out the txnParticipant.
-        txnParticipant->abortArbitraryTransaction();
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
+        txnParticipant.abortTransactionIfNotPrepared(opCtx());
+        ASSERT_FALSE(txnParticipant.transactionIsAborted());
     };
 
     // Check that prepareTimestamp gets set.
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     ASSERT_EQ(ruPrepareTimestamp, prepareTimestamp);
     // Check that the oldest prepareTimestamp is the one we just set.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), prepareTimestamp);
     ASSERT(_opObserver->transactionPrepared);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
-}
-
-DEATH_TEST_F(TxnParticipantTest, AbortDuringPrepareIsFatal, "Invariant") {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-
-    auto originalFn = _opObserver->onTransactionPrepareFn;
-    _opObserver->onTransactionPrepareFn = [&]() {
-        originalFn();
-
-        // The transaction may be aborted without checking out the txnParticipant.
-        txnParticipant->abortActiveTransaction(opCtx());
-        ASSERT(txnParticipant->transactionIsAborted());
-    };
-
-    txnParticipant->prepareTransaction(opCtx(), {});
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, ThrowDuringOnTransactionPrepareAbortsTransaction) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
     _opObserver->onTransactionPrepareThrowsException = true;
 
-    ASSERT_THROWS_CODE(txnParticipant->prepareTransaction(opCtx(), {}),
+    ASSERT_THROWS_CODE(txnParticipant.prepareTransaction(opCtx(), {}),
                        AssertionException,
                        ErrorCodes::OperationFailed);
     ASSERT_FALSE(_opObserver->transactionPrepared);
-    ASSERT(txnParticipant->transactionIsAborted());
-}
-
-TEST_F(TxnParticipantTest, KillSessionsDuringPreparedCommitDoesNotAbortTransaction) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
-    const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
-
-    auto originalFn = _opObserver->onTransactionCommitFn;
-    _opObserver->onTransactionCommitFn = [&](boost::optional<OplogSlot> commitOplogEntryOpTime,
-                                             boost::optional<Timestamp> commitTimestamp,
-                                             std::vector<repl::ReplOperation>& statements) {
-        originalFn(commitOplogEntryOpTime, commitTimestamp, statements);
-        ASSERT(commitOplogEntryOpTime);
-        ASSERT(commitTimestamp);
-
-        ASSERT_GT(*commitTimestamp, prepareTimestamp);
-
-        ASSERT(statements.empty());
-
-        // The transaction may be aborted without checking out the txnParticipant.
-        txnParticipant->abortArbitraryTransaction();
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    };
-
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
-
-    // The recovery unit is reset on commit.
-    ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
-
-    ASSERT(_opObserver->transactionCommitted);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    ASSERT(txnParticipant->transactionIsCommitted());
+    ASSERT(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, StepDownAfterPrepareDoesNotBlock) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     // Test that we can acquire the RSTL in mode X, and then immediately release it so the test can
     // complete successfully.
@@ -937,17 +718,17 @@ TEST_F(TxnParticipantTest, StepDownAfterPrepareDoesNotBlock) {
     };
     runFunctionFromDifferentOpCtx(func);
 
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
     ASSERT(_opObserver->transactionAborted);
-    ASSERT(txnParticipant->transactionIsAborted());
+    ASSERT(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, StepDownAfterPrepareDoesNotBlockThenCommit) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     // Test that we can acquire the RSTL in mode X, and then immediately release it so the test can
@@ -960,118 +741,82 @@ TEST_F(TxnParticipantTest, StepDownAfterPrepareDoesNotBlockThenCommit) {
     };
     runFunctionFromDifferentOpCtx(func);
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
     ASSERT(_opObserver->transactionCommitted);
-    ASSERT(txnParticipant->transactionIsCommitted());
+    ASSERT(txnParticipant.transactionIsCommitted());
 }
 
 TEST_F(TxnParticipantTest, StepDownDuringAbortSucceeds) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     ASSERT_OK(repl::ReplicationCoordinator::get(opCtx())->setFollowerMode(
         repl::MemberState::RS_SECONDARY));
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
     ASSERT(_opObserver->transactionAborted);
-    ASSERT(txnParticipant->transactionIsAborted());
+    ASSERT(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, StepDownDuringPreparedAbortFails) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     ASSERT_OK(repl::ReplicationCoordinator::get(opCtx())->setFollowerMode(
         repl::MemberState::RS_SECONDARY));
     ASSERT_THROWS_CODE(
-        txnParticipant->abortActiveTransaction(opCtx()), AssertionException, ErrorCodes::NotMaster);
+        txnParticipant.abortActiveTransaction(opCtx()), AssertionException, ErrorCodes::NotMaster);
 }
 
 TEST_F(TxnParticipantTest, StepDownDuringPreparedCommitFails) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
 
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     ASSERT_OK(repl::ReplicationCoordinator::get(opCtx())->setFollowerMode(
         repl::MemberState::RS_SECONDARY));
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {}),
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {}),
                        AssertionException,
                        ErrorCodes::NotMaster);
 }
 
-TEST_F(TxnParticipantTest, ArbitraryAbortDuringPreparedCommitDoesNotAbortTransaction) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
-    const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
-
-    auto originalFn = _opObserver->onTransactionCommitFn;
-    _opObserver->onTransactionCommitFn = [&](boost::optional<OplogSlot> commitOplogEntryOpTime,
-                                             boost::optional<Timestamp> commitTimestamp,
-                                             std::vector<repl::ReplOperation>& statements) {
-        originalFn(commitOplogEntryOpTime, commitTimestamp, statements);
-        ASSERT(commitOplogEntryOpTime);
-        ASSERT(commitTimestamp);
-
-        ASSERT_GT(*commitTimestamp, prepareTimestamp);
-
-        ASSERT(statements.empty());
-
-        // The transaction may be aborted without checking out the txnParticipant.
-        auto func = [&](OperationContext* opCtx) { txnParticipant->abortArbitraryTransaction(); };
-        runFunctionFromDifferentOpCtx(func);
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    };
-
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
-
-    // The recovery unit is reset on commit.
-    ASSERT(opCtx()->recoveryUnit()->getCommitTimestamp().isNull());
-
-    ASSERT(_opObserver->transactionCommitted);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    ASSERT(txnParticipant->transactionIsCommitted());
-}
-
 DEATH_TEST_F(TxnParticipantTest,
              ThrowDuringPreparedOnTransactionCommitIsFatal,
              "Caught exception during commit") {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     _opObserver->onTransactionCommitThrowsException = true;
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
 }
 
 TEST_F(TxnParticipantTest, ThrowDuringUnpreparedCommitLetsTheAbortAtEntryPointToCleanUp) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     _opObserver->onTransactionCommitThrowsException = true;
 
-    ASSERT_THROWS_CODE(txnParticipant->commitUnpreparedTransaction(opCtx()),
+    ASSERT_THROWS_CODE(txnParticipant.commitUnpreparedTransaction(opCtx()),
                        AssertionException,
                        ErrorCodes::OperationFailed);
     ASSERT_FALSE(_opObserver->transactionCommitted);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
-    ASSERT_FALSE(txnParticipant->transactionIsCommitted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsCommitted());
 
     // Simulate the abort at entry point.
-    txnParticipant->abortActiveUnpreparedOrStashPreparedTransaction(opCtx());
-    ASSERT_TRUE(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveUnpreparedOrStashPreparedTransaction(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsAborted());
 }
 
 TEST_F(TxnParticipantTest, ContinuingATransactionWithNoResourcesAborts) {
@@ -1083,7 +828,7 @@ TEST_F(TxnParticipantTest, ContinuingATransactionWithNoResourcesAborts) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     ASSERT_THROWS_CODE(
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, boost::none),
+        txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, boost::none),
         AssertionException,
         ErrorCodes::NoSuchTransaction);
 }
@@ -1092,7 +837,7 @@ TEST_F(TxnParticipantTest, KillSessionsDoesNotAbortPreparedTransactions) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     auto ruPrepareTimestamp = Timestamp();
     auto originalFn = _opObserver->onTransactionPrepareFn;
@@ -1103,23 +848,23 @@ TEST_F(TxnParticipantTest, KillSessionsDoesNotAbortPreparedTransactions) {
     };
 
     // Check that prepareTimestamp gets set.
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     ASSERT_EQ(ruPrepareTimestamp, prepareTimestamp);
     // Check that the oldest prepareTimestamp is the one we just set.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), prepareTimestamp);
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
     ASSERT(_opObserver->transactionPrepared);
 }
 
-TEST_F(TxnParticipantTest, TransactionTimeoutDoesNotAbortPreparedTransactions) {
+TEST_F(TxnParticipantTest, CannotAbortArbitraryPreparedTransactions) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     auto ruPrepareTimestamp = Timestamp();
     auto originalFn = _opObserver->onTransactionPrepareFn;
@@ -1130,16 +875,15 @@ TEST_F(TxnParticipantTest, TransactionTimeoutDoesNotAbortPreparedTransactions) {
     };
 
     // Check that prepareTimestamp gets set.
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     ASSERT_EQ(ruPrepareTimestamp, prepareTimestamp);
     // Check that the oldest prepareTimestamp is the one we just set.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), prepareTimestamp);
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
-    ASSERT(!txnParticipant->expired());
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT(!txnParticipant->transactionIsAborted());
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT(!txnParticipant.transactionIsAborted());
     ASSERT(_opObserver->transactionPrepared);
 }
 
@@ -1147,7 +891,7 @@ TEST_F(TxnParticipantTest, CannotStartNewTransactionWhilePreparedTransactionInPr
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     auto ruPrepareTimestamp = Timestamp();
     auto originalFn = _opObserver->onTransactionPrepareFn;
@@ -1159,37 +903,36 @@ TEST_F(TxnParticipantTest, CannotStartNewTransactionWhilePreparedTransactionInPr
     };
 
     // Check that prepareTimestamp gets set.
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     ASSERT_EQ(ruPrepareTimestamp, prepareTimestamp);
 
     // Check that the oldest prepareTimestamp is the one we just set.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), prepareTimestamp);
 
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     OperationContextSession::checkIn(opCtx());
     {
+        auto guard = makeGuard([&]() { OperationContextSession::checkOut(opCtx()); });
         // Try to start a new transaction while there is already a prepared transaction on the
         // session. This should fail with a PreparedTransactionInProgress error.
-        auto func = [
+        runFunctionFromDifferentOpCtx([
             lsid = *opCtx()->getLogicalSessionId(),
             txnNumberToStart = *opCtx()->getTxnNumber() + 1
         ](OperationContext * newOpCtx) {
             newOpCtx->setLogicalSessionId(lsid);
             newOpCtx->setTxnNumber(txnNumberToStart);
+
             MongoDOperationContextSession ocs(newOpCtx);
             auto txnParticipant = TransactionParticipant::get(newOpCtx);
-
-            ASSERT_THROWS_CODE(txnParticipant->beginOrContinue(txnNumberToStart, false, true),
-                               AssertionException,
-                               ErrorCodes::PreparedTransactionInProgress);
-        };
-
-        runFunctionFromDifferentOpCtx(func);
+            ASSERT_THROWS_CODE(
+                txnParticipant.beginOrContinue(newOpCtx, txnNumberToStart, false, true),
+                AssertionException,
+                ErrorCodes::PreparedTransactionInProgress);
+        });
     }
-    OperationContextSession::checkOut(opCtx());
 
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
     ASSERT(_opObserver->transactionPrepared);
 }
 
@@ -1197,17 +940,17 @@ TEST_F(TxnParticipantTest, CannotInsertInPreparedTransaction) {
     auto outerScopedSession = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
 
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
 
-    ASSERT_THROWS_CODE(txnParticipant->unstashTransactionResources(opCtx(), "insert"),
+    ASSERT_THROWS_CODE(txnParticipant.unstashTransactionResources(opCtx(), "insert"),
                        AssertionException,
                        ErrorCodes::PreparedTransactionInProgress);
 
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
     ASSERT(_opObserver->transactionPrepared);
 }
 
@@ -1215,50 +958,44 @@ TEST_F(TxnParticipantTest, ImplictAbortDoesNotAbortPreparedTransaction) {
     auto outerScopedSession = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
 
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     // The next command throws an exception and wants to abort the transaction.
     // This is a no-op.
-    txnParticipant->abortActiveUnpreparedOrStashPreparedTransaction(opCtx());
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveUnpreparedOrStashPreparedTransaction(opCtx());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
     ASSERT_TRUE(_opObserver->transactionPrepared);
 }
 
-DEATH_TEST_F(TxnParticipantTest, AbortIsIllegalDuringCommittingPreparedTransaction, "invariant") {
+DEATH_TEST_F(TxnParticipantTest,
+             AbortIsIllegalDuringCommittingPreparedTransaction,
+             "isCommittingWithPrepare") {
     auto outerScopedSession = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.addTransactionOperation(opCtx(), operation);
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     auto commitTS = Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     // Check that the oldest prepareTimestamp is the one we just set.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), prepareTimestamp);
 
-    auto sessionId = *opCtx()->getLogicalSessionId();
-    auto txnNum = *opCtx()->getTxnNumber();
     _opObserver->onTransactionCommitFn = [&](boost::optional<OplogSlot> commitOplogEntryOpTime,
                                              boost::optional<Timestamp> commitTimestamp,
                                              std::vector<repl::ReplOperation>& statements) {
-        // This should never happen.
-        auto func = [&](OperationContext* opCtx) {
-            opCtx->setLogicalSessionId(sessionId);
-            opCtx->setTxnNumber(txnNum);
-            // Hit an invariant. This should never happen.
-            txnParticipant->abortActiveTransaction(opCtx);
-        };
-        runFunctionFromDifferentOpCtx(func);
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
+        // Hit an invariant. This should never happen.
+        txnParticipant.abortActiveTransaction(opCtx());
+        ASSERT_FALSE(txnParticipant.transactionIsAborted());
     };
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTS, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTS, {});
     // Check that we removed the prepareTimestamp from the set.
     ASSERT_FALSE(ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime());
 }
@@ -1267,7 +1004,7 @@ TEST_F(TxnParticipantTest, CannotContinueNonExistentTransaction) {
     MongoDOperationContextSession opCtxSession(opCtx());
     auto txnParticipant = TransactionParticipant::get(opCtx());
     ASSERT_THROWS_CODE(
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), false, boost::none),
+        txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), false, boost::none),
         AssertionException,
         ErrorCodes::NoSuchTransaction);
 }
@@ -1277,7 +1014,7 @@ TEST_F(TxnParticipantTest, TransactionTooLargeWhileBuilding) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     // Two 6MB operations should succeed; three 6MB operations should fail.
     constexpr size_t kBigDataSize = 6 * 1024 * 1024;
@@ -1286,9 +1023,9 @@ TEST_F(TxnParticipantTest, TransactionTooLargeWhileBuilding) {
         kNss,
         kUUID,
         BSON("_id" << 0 << "data" << BSONBinData(bigData.get(), kBigDataSize, BinDataGeneral)));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
-    txnParticipant->addTransactionOperation(opCtx(), operation);
-    ASSERT_THROWS_CODE(txnParticipant->addTransactionOperation(opCtx(), operation),
+    txnParticipant.addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
+    ASSERT_THROWS_CODE(txnParticipant.addTransactionOperation(opCtx(), operation),
                        AssertionException,
                        ErrorCodes::TransactionTooLarge);
 }
@@ -1311,7 +1048,7 @@ TEST_F(TxnParticipantTest, StashInNestedSessionIsANoop) {
 
     // Perform initial unstash, which sets up a WriteUnitOfWork.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
     ASSERT_EQUALS(originalLocker, opCtx()->lockState());
     ASSERT_EQUALS(originalRecoveryUnit, opCtx()->recoveryUnit());
     ASSERT(opCtx()->getWriteUnitOfWork());
@@ -1319,7 +1056,7 @@ TEST_F(TxnParticipantTest, StashInNestedSessionIsANoop) {
     {
         // Make it look like we're in a DBDirectClient running a nested operation.
         DirectClientSetter inDirectClient(opCtx());
-        txnParticipant->stashTransactionResources(opCtx());
+        txnParticipant.stashTransactionResources(opCtx());
 
         // The stash was a noop, so the locker, RecoveryUnit, and WriteUnitOfWork on the
         // OperationContext are unaffected.
@@ -1344,12 +1081,12 @@ protected:
         auto sessionCheckout = checkOutSession();
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
 
-        ASSERT_THROWS_CODE(
-            txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-            AssertionException,
-            50911);
+        ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                               opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                           AssertionException,
+                           50911);
     }
 
     void canSpecifyStartTransactionOnAbortedTxn() {
@@ -1358,13 +1095,14 @@ protected:
         auto sessionCheckout = checkOutSession();
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
 
-        txnParticipant->abortActiveTransaction(opCtx());
-        ASSERT(txnParticipant->transactionIsAborted());
+        txnParticipant.abortActiveTransaction(opCtx());
+        ASSERT(txnParticipant.transactionIsAborted());
 
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction);
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        txnParticipant.beginOrContinue(
+            opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction);
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
     }
 
     void cannotSpecifyStartTransactionOnCommittedTxn() {
@@ -1373,15 +1111,15 @@ protected:
         auto sessionCheckout = checkOutSession();
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
 
-        txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-        txnParticipant->commitUnpreparedTransaction(opCtx());
+        txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+        txnParticipant.commitUnpreparedTransaction(opCtx());
 
-        ASSERT_THROWS_CODE(
-            txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-            AssertionException,
-            50911);
+        ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                               opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                           AssertionException,
+                           50911);
     }
 
     void cannotSpecifyStartTransactionOnPreparedTxn() {
@@ -1390,32 +1128,32 @@ protected:
         auto sessionCheckout = checkOutSession();
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
 
-        txnParticipant->unstashTransactionResources(opCtx(), "insert");
+        txnParticipant.unstashTransactionResources(opCtx(), "insert");
         auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-        txnParticipant->addTransactionOperation(opCtx(), operation);
-        txnParticipant->prepareTransaction(opCtx(), {});
+        txnParticipant.addTransactionOperation(opCtx(), operation);
+        txnParticipant.prepareTransaction(opCtx(), {});
 
-        ASSERT_THROWS_CODE(
-            txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-            AssertionException,
-            50911);
+        ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                               opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                           AssertionException,
+                           50911);
     }
 
     void cannotSpecifyStartTransactionOnStartedRetryableWrite() {
         MongoDOperationContextSession opCtxSession(opCtx());
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), boost::none, boost::none);
-        ASSERT_FALSE(txnParticipant->inMultiDocumentTransaction());
+        txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), boost::none, boost::none);
+        ASSERT_FALSE(txnParticipant.inMultiDocumentTransaction());
 
         auto autocommit = false;
         auto startTransaction = true;
-        ASSERT_THROWS_CODE(
-            txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-            AssertionException,
-            50911);
+        ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                               opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                           AssertionException,
+                           50911);
     }
 
     void cannotSpecifyStartTransactionOnAbortedPreparedTransaction() {
@@ -1424,20 +1162,20 @@ protected:
         auto sessionCheckout = checkOutSession();
 
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->inMultiDocumentTransaction());
+        ASSERT(txnParticipant.inMultiDocumentTransaction());
 
-        txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-        txnParticipant->prepareTransaction(opCtx(), {});
-        ASSERT(txnParticipant->transactionIsPrepared());
+        txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+        txnParticipant.prepareTransaction(opCtx(), {});
+        ASSERT(txnParticipant.transactionIsPrepared());
 
-        txnParticipant->abortActiveTransaction(opCtx());
-        ASSERT(txnParticipant->transactionIsAborted());
+        txnParticipant.abortActiveTransaction(opCtx());
+        ASSERT(txnParticipant.transactionIsAborted());
 
         startTransaction = true;
-        ASSERT_THROWS_CODE(
-            txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-            AssertionException,
-            50911);
+        ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                               opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                           AssertionException,
+                           50911);
     }
 };
 
@@ -1521,97 +1259,27 @@ TEST_F(ConfigTxnParticipantTest, CannotSpecifyStartTransactionOnAbortedPreparedT
     cannotSpecifyStartTransactionOnAbortedPreparedTransaction();
 }
 
-TEST_F(TxnParticipantTest, KillSessionsDuringUnpreparedAbortSucceeds) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-
-    auto originalFn = _opObserver->onTransactionAbortFn;
-    _opObserver->onTransactionAbortFn = [&] {
-        originalFn();
-
-        // The transaction may be aborted without checking out the txnParticipant.
-        txnParticipant->abortArbitraryTransaction();
-        ASSERT(txnParticipant->transactionIsAborted());
-    };
-
-    txnParticipant->abortActiveTransaction(opCtx());
-
-    ASSERT(_opObserver->transactionAborted);
-    ASSERT(txnParticipant->transactionIsAborted());
-}
-
-TEST_F(TxnParticipantTest, ActiveAbortIsLegalDuringUnpreparedAbort) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-
-    auto sessionId = *opCtx()->getLogicalSessionId();
-    auto txnNumber = *opCtx()->getTxnNumber();
-    auto originalFn = _opObserver->onTransactionAbortFn;
-    _opObserver->onTransactionAbortFn = [&] {
-        originalFn();
-
-        auto func = [&](OperationContext* opCtx) {
-            opCtx->setLogicalSessionId(sessionId);
-            opCtx->setTxnNumber(txnNumber);
-
-            // Prevent recursion.
-            _opObserver->onTransactionAbortFn = originalFn;
-            txnParticipant->abortActiveTransaction(opCtx);
-            ASSERT(txnParticipant->transactionIsAborted());
-        };
-        runFunctionFromDifferentOpCtx(func);
-    };
-
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(_opObserver->transactionAborted);
-    ASSERT(txnParticipant->transactionIsAborted());
-}
-
 TEST_F(TxnParticipantTest, ThrowDuringUnpreparedOnTransactionAbort) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     _opObserver->onTransactionAbortThrowsException = true;
 
-    ASSERT_THROWS_CODE(txnParticipant->abortActiveTransaction(opCtx()),
+    ASSERT_THROWS_CODE(txnParticipant.abortActiveTransaction(opCtx()),
                        AssertionException,
                        ErrorCodes::OperationFailed);
 }
 
-TEST_F(TxnParticipantTest, KillSessionsDuringPreparedAbortFails) {
-    auto sessionCheckout = checkOutSession();
-    auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
-
-    auto originalFn = _opObserver->onTransactionAbortFn;
-    _opObserver->onTransactionAbortFn = [&] {
-        originalFn();
-
-        // KillSessions may attempt to abort without checking out the txnParticipant.
-        txnParticipant->abortArbitraryTransaction();
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
-        ASSERT(txnParticipant->transactionIsPrepared());
-    };
-
-    txnParticipant->abortActiveTransaction(opCtx());
-
-    ASSERT(_opObserver->transactionAborted);
-    ASSERT(txnParticipant->transactionIsAborted());
-}
-
 TEST_F(TxnParticipantTest, ThrowDuringPreparedOnTransactionAbortIsFatal) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     _opObserver->onTransactionAbortThrowsException = true;
 
-    ASSERT_THROWS_CODE(txnParticipant->abortActiveTransaction(opCtx()),
+    ASSERT_THROWS_CODE(txnParticipant.abortActiveTransaction(opCtx()),
                        AssertionException,
                        ErrorCodes::OperationFailed);
 }
@@ -1628,16 +1296,16 @@ TEST_F(TxnParticipantTest, ReacquireLocksForPreparedTransactionsOnStepUp) {
         repl::UnreplicatedWritesBlock uwb(opCtx());
         ASSERT(!opCtx()->writesAreReplicated());
 
-        txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+        txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
         // Simulate the locking of an insert.
         {
             Lock::DBLock dbLock(opCtx(), "test", MODE_IX);
             Lock::CollectionLock collLock(opCtx()->lockState(), "test.foo", MODE_IX);
         }
-        txnParticipant->prepareTransaction(opCtx(), repl::OpTime({1, 1}, 1));
-        txnParticipant->stashTransactionResources(opCtx());
+        txnParticipant.prepareTransaction(opCtx(), repl::OpTime({1, 1}, 1));
+        txnParticipant.stashTransactionResources(opCtx());
         // Secondary yields locks for prepared transactions.
-        ASSERT_FALSE(txnParticipant->getTxnResourceStashLockerForTest()->isLocked());
+        ASSERT_FALSE(txnParticipant.getTxnResourceStashLockerForTest()->isLocked());
     }
 
     // Step-up will restore the locks of prepared transactions.
@@ -1646,9 +1314,9 @@ TEST_F(TxnParticipantTest, ReacquireLocksForPreparedTransactionsOnStepUp) {
     {
         auto sessionCheckout = checkOutSession({});
         auto txnParticipant = TransactionParticipant::get(opCtx());
-        ASSERT(txnParticipant->getTxnResourceStashLockerForTest()->isLocked());
-        txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-        txnParticipant->abortActiveTransaction(opCtx());
+        ASSERT(txnParticipant.getTxnResourceStashLockerForTest()->isLocked());
+        txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+        txnParticipant.abortActiveTransaction(opCtx());
     }
 }
 
@@ -1697,8 +1365,8 @@ TEST_F(TransactionsMetricsTest, IncrementPreparedTransaction) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
     unsigned long long beforePrepareCount =
         ServerTransactionsMetrics::get(opCtx())->getTotalPrepared();
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalPrepared(), beforePrepareCount + 1U);
 }
@@ -1706,12 +1374,12 @@ TEST_F(TransactionsMetricsTest, IncrementPreparedTransaction) {
 TEST_F(TransactionsMetricsTest, IncrementTotalCommittedOnCommit) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     unsigned long long beforeCommitCount =
         ServerTransactionsMetrics::get(opCtx())->getTotalCommitted();
 
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     // Assert that the committed counter is incremented by 1.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalCommitted(), beforeCommitCount + 1U);
@@ -1720,17 +1388,17 @@ TEST_F(TransactionsMetricsTest, IncrementTotalCommittedOnCommit) {
 TEST_F(TransactionsMetricsTest, IncrementTotalPreparedThenCommitted) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     unsigned long long beforePreparedThenCommittedCount =
         ServerTransactionsMetrics::get(opCtx())->getTotalPreparedThenCommitted();
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
 
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalPreparedThenCommitted(),
               beforePreparedThenCommittedCount + 1U);
 }
@@ -1739,12 +1407,12 @@ TEST_F(TransactionsMetricsTest, IncrementTotalPreparedThenCommitted) {
 TEST_F(TransactionsMetricsTest, IncrementTotalAbortedUponAbort) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     unsigned long long beforeAbortCount =
         ServerTransactionsMetrics::get(opCtx())->getTotalAborted();
 
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
 
     // Assert that the aborted counter is incremented by 1.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalAborted(), beforeAbortCount + 1U);
@@ -1756,11 +1424,11 @@ TEST_F(TransactionsMetricsTest, IncrementTotalPreparedThenAborted) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
 
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalPreparedThenAborted(),
               beforePreparedThenAbortedCount + 1U);
 }
@@ -1771,15 +1439,15 @@ TEST_F(TransactionsMetricsTest, IncrementCurrentPreparedWithCommit) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentPrepared(),
               beforeCurrentPrepared + 1U);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
-    ASSERT(txnParticipant->transactionIsCommitted());
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    ASSERT(txnParticipant.transactionIsCommitted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentPrepared(), beforeCurrentPrepared);
 }
 
@@ -1789,13 +1457,13 @@ TEST_F(TransactionsMetricsTest, IncrementCurrentPreparedWithAbort) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentPrepared(),
               beforeCurrentPrepared + 1U);
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentPrepared(), beforeCurrentPrepared);
 }
 
@@ -1806,18 +1474,18 @@ TEST_F(TransactionsMetricsTest, TrackTotalOpenTransactionsWithAbort) {
     // Tests that starting a transaction increments the open transactions counter by 1.
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(),
               beforeTransactionStart + 1U);
 
     // Tests that stashing the transaction resources does not affect the open transactions counter.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(),
               beforeTransactionStart + 1U);
 
     // Tests that aborting a transaction decrements the open transactions counter by 1.
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(), beforeTransactionStart);
 }
 
@@ -1828,20 +1496,20 @@ TEST_F(TransactionsMetricsTest, TrackTotalOpenTransactionsWithCommit) {
     // Tests that starting a transaction increments the open transactions counter by 1.
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(),
               beforeTransactionStart + 1U);
 
     // Tests that stashing the transaction resources does not affect the open transactions counter.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(),
               beforeTransactionStart + 1U);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     // Tests that committing a transaction decrements the open transactions counter by 1.
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentOpen(), beforeTransactionStart);
 }
 
@@ -1859,7 +1527,7 @@ TEST_F(TransactionsMetricsTest, TrackTotalActiveAndInactiveTransactionsWithCommi
     // Tests that the first unstash increments the active counter and decrements the inactive
     // counter.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActiveCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
@@ -1867,20 +1535,20 @@ TEST_F(TransactionsMetricsTest, TrackTotalActiveAndInactiveTransactionsWithCommi
     // Tests that stashing the transaction resources decrements active counter and increments
     // inactive counter.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactiveCounter + 1U);
 
     // Tests that the second unstash increments the active counter and decrements the inactive
     // counter.
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActiveCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
 
     // Tests that committing a transaction decrements the active counter only.
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
 }
@@ -1899,7 +1567,7 @@ TEST_F(TransactionsMetricsTest, TrackTotalActiveAndInactiveTransactionsWithStash
     // Tests that the first unstash increments the active counter and decrements the inactive
     // counter.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActiveCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
@@ -1907,13 +1575,13 @@ TEST_F(TransactionsMetricsTest, TrackTotalActiveAndInactiveTransactionsWithStash
     // Tests that stashing the transaction resources decrements active counter and increments
     // inactive counter.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactiveCounter + 1U);
 
     // Tests that aborting a stashed transaction decrements the inactive counter only.
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
 }
@@ -1932,13 +1600,13 @@ TEST_F(TransactionsMetricsTest, TrackTotalActiveAndInactiveTransactionsWithUnsta
     // Tests that the first unstash increments the active counter and decrements the inactive
     // counter.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActiveCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
 
     // Tests that aborting a stashed transaction decrements the active counter only.
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(), beforeInactiveCounter);
 }
@@ -1956,8 +1624,8 @@ TEST_F(TransactionsMetricsTest, TrackCurrentActiveAndInactivePreparedTransaction
 
     // Tests that unstashing a transaction puts it into an active state.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
@@ -1968,21 +1636,21 @@ TEST_F(TransactionsMetricsTest, TrackCurrentActiveAndInactivePreparedTransaction
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalPrepared(), beforePrepareCount + 1U);
 
     // Tests that the first stash decrements the active counter and increments the inactive counter.
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactivePreparedCounter + 1U);
 
     // Tests that unstashing increments the active counter and decrements the inactive counter.
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactivePreparedCounter);
 
     // Tests that committing decrements the active counter only.
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
@@ -2002,8 +1670,8 @@ TEST_F(TransactionsMetricsTest,
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Tests that unstashing a transaction increments the active counter only.
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
@@ -2011,20 +1679,20 @@ TEST_F(TransactionsMetricsTest,
 
     // Tests that stashing a prepared transaction decrements the active counter and increments the
     // inactive counter.
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactivePreparedCounter + 1U);
 
     // Tests that aborting a stashed prepared transaction decrements the inactive counter only.
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter + 1U);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
               beforeInactivePreparedCounter);
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(),
               beforeActivePreparedCounter);
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentInactive(),
@@ -2055,10 +1723,10 @@ TEST_F(TransactionsMetricsTest, TransactionErrorsBeforeUnstash) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
     const bool autocommit = false;
     const boost::optional<bool> startTransaction = boost::none;
-    ASSERT_THROWS_CODE(
-        txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), autocommit, startTransaction),
-        AssertionException,
-        ErrorCodes::NoSuchTransaction);
+    ASSERT_THROWS_CODE(txnParticipant.beginOrContinue(
+                           opCtx(), *opCtx()->getTxnNumber(), autocommit, startTransaction),
+                       AssertionException,
+                       ErrorCodes::NoSuchTransaction);
 
     // The transaction is now aborted.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getCurrentActive(), beforeActiveCounter);
@@ -2072,16 +1740,16 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsDurationShouldBeSetUponCom
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
     // Advance the clock.
     tickSource->advance(Microseconds(100));
 
-    txnParticipant->commitUnpreparedTransaction(opCtx());
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    txnParticipant.commitUnpreparedTransaction(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(100));
 }
 
@@ -2090,7 +1758,7 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsPreparedDurationShouldBeSe
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
@@ -2098,14 +1766,14 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsPreparedDurationShouldBeSe
     tickSource->advance(Microseconds(10));
 
     // Prepare the transaction and extend the duration in the prepared state.
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     tickSource->advance(Microseconds(100));
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(100));
 }
@@ -2115,14 +1783,14 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsDurationShouldBeSetUponAbo
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     // Advance the clock.
     tickSource->advance(Microseconds(100));
 
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(100));
 }
 
@@ -2131,17 +1799,17 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsPreparedDurationShouldBeSe
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     // Advance the clock.
     tickSource->advance(Microseconds(10));
 
     // Prepare the transaction and extend the duration in the prepared state.
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
     tickSource->advance(Microseconds(100));
 
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(100));
 }
@@ -2151,29 +1819,29 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsDurationShouldKeepIncreasi
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
     tickSource->advance(Microseconds(100));
 
     // The transaction's duration should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(100));
 
     tickSource->advance(Microseconds(100));
 
     // Commit the transaction and check duration.
-    txnParticipant->commitUnpreparedTransaction(opCtx());
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    txnParticipant.commitUnpreparedTransaction(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(200));
 
     // The transaction committed, so the duration shouldn't have increased even if more time passed.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(200));
 }
 
@@ -2183,34 +1851,34 @@ TEST_F(TransactionsMetricsTest,
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
     // Prepare the transaction and extend the duration in the prepared state.
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     tickSource->advance(Microseconds(100));
 
     // The prepared transaction's duration should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(100));
 
     tickSource->advance(Microseconds(100));
 
     // Commit the prepared transaction and check the prepared duration.
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 
     // The prepared transaction committed, so the prepared duration shouldn't have increased even if
     // more time passed.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 }
@@ -2220,29 +1888,29 @@ TEST_F(TransactionsMetricsTest, SingleTransactionStatsDurationShouldKeepIncreasi
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
     tickSource->advance(Microseconds(100));
 
     // The transaction's duration should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(100));
 
     tickSource->advance(Microseconds(100));
 
     // Abort the transaction and check duration.
-    txnParticipant->abortArbitraryTransaction();
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(200));
 
     // The transaction aborted, so the duration shouldn't have increased even if more time passed.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getDuration(
-                  tickSource, tickSource->getTicks()),
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getDuration(tickSource,
+                                                                            tickSource->getTicks()),
               Microseconds(200));
 }
 
@@ -2252,31 +1920,31 @@ TEST_F(TransactionsMetricsTest,
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
 
     // Prepare the transaction and extend the duration in the prepared state.
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
     tickSource->advance(Microseconds(100));
 
     // The prepared transaction's duration should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(100));
 
     tickSource->advance(Microseconds(100));
 
     // Abort the prepared transaction and check the prepared duration.
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 
     // The prepared transaction aborted, so the prepared duration shouldn't have increased even if
     // more time passed.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 }
@@ -2288,42 +1956,42 @@ TEST_F(TransactionsMetricsTest, TimeActiveMicrosShouldBeSetUponUnstashAndStash)
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time active should be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     tickSource->advance(Microseconds(100));
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     // Advance clock during inactive period.
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased only during active period.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     tickSource->advance(Microseconds(100));
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     // Advance clock during inactive period.
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased again.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{200});
 
     // Start a new transaction.
     const auto higherTxnNum = *opCtx()->getTxnNumber() + 1;
-    txnParticipant->beginOrContinue(higherTxnNum, false, true);
+    txnParticipant.beginOrContinue(opCtx(), higherTxnNum, false, true);
 
     // Time active should be zero for a new transaction.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 }
@@ -2335,23 +2003,23 @@ TEST_F(TransactionsMetricsTest, TimeActiveMicrosShouldBeSetUponUnstashAndAbort)
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time active should be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     tickSource->advance(Microseconds(100));
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
 
     // Time active should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
     tickSource->advance(Microseconds(100));
 
     // The transaction is not active after abort, so time active should not have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 }
@@ -2363,17 +2031,17 @@ TEST_F(TransactionsMetricsTest, TimeActiveMicrosShouldNotBeSetUponAbortOnly) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time active should be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 
     // Advance clock during inactive period.
     tickSource->advance(Microseconds(100));
 
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
 
     // Time active should still be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 }
@@ -2385,32 +2053,32 @@ TEST_F(TransactionsMetricsTest, TimeActiveMicrosShouldIncreaseUntilStash) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time active should be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds(100));
 
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased again.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     tickSource->advance(Microseconds(100));
 
     // The transaction is no longer active, so time active should have stopped increasing.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 }
@@ -2422,31 +2090,31 @@ TEST_F(TransactionsMetricsTest, TimeActiveMicrosShouldIncreaseUntilCommit) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time active should be zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
     tickSource->advance(Microseconds(100));
 
     // Time active should have increased again.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{200});
 
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     tickSource->advance(Microseconds(100));
 
     // The transaction is no longer active, so time active should have stopped increasing.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds(200));
 }
@@ -2456,37 +2124,36 @@ TEST_F(TransactionsMetricsTest, AdditiveMetricsObjectsShouldBeAddedTogetherUponS
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Initialize field values for both AdditiveMetrics objects.
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
         1;
     CurOp::get(opCtx())->debug().additiveMetrics.keysExamined = 5;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
         2;
     CurOp::get(opCtx())->debug().additiveMetrics.docsExamined = 0;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 3;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 1;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 3;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 1;
     CurOp::get(opCtx())->debug().additiveMetrics.nModified = 1;
     CurOp::get(opCtx())->debug().additiveMetrics.ninserted = 4;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
         1;
     CurOp::get(opCtx())->debug().additiveMetrics.keysInserted = 1;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysDeleted =
-        0;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysDeleted = 0;
     CurOp::get(opCtx())->debug().additiveMetrics.keysDeleted = 0;
-    txnParticipant->getSingleTransactionStatsForTest()
+    txnParticipant.getSingleTransactionStatsForTest()
         .getOpDebug()
         ->additiveMetrics.prepareReadConflicts = 5;
     CurOp::get(opCtx())->debug().additiveMetrics.prepareReadConflicts = 4;
 
     auto additiveMetricsToCompare =
-        txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
+        txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
     additiveMetricsToCompare.add(CurOp::get(opCtx())->debug().additiveMetrics);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
-    ASSERT(txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
+    ASSERT(txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
         additiveMetricsToCompare));
 }
 
@@ -2495,40 +2162,39 @@ TEST_F(TransactionsMetricsTest, AdditiveMetricsObjectsShouldBeAddedTogetherUponC
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Initialize field values for both AdditiveMetrics objects.
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
         3;
     CurOp::get(opCtx())->debug().additiveMetrics.keysExamined = 2;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
         0;
     CurOp::get(opCtx())->debug().additiveMetrics.docsExamined = 2;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 4;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 5;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 4;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 5;
     CurOp::get(opCtx())->debug().additiveMetrics.nModified = 1;
     CurOp::get(opCtx())->debug().additiveMetrics.ninserted = 1;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.ndeleted = 4;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.ndeleted = 4;
     CurOp::get(opCtx())->debug().additiveMetrics.ndeleted = 0;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
         1;
     CurOp::get(opCtx())->debug().additiveMetrics.keysInserted = 1;
-    txnParticipant->getSingleTransactionStatsForTest()
+    txnParticipant.getSingleTransactionStatsForTest()
         .getOpDebug()
         ->additiveMetrics.prepareReadConflicts = 0;
     CurOp::get(opCtx())->debug().additiveMetrics.prepareReadConflicts = 0;
-    txnParticipant->getSingleTransactionStatsForTest()
-        .getOpDebug()
-        ->additiveMetrics.writeConflicts = 6;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.writeConflicts =
+        6;
     CurOp::get(opCtx())->debug().additiveMetrics.writeConflicts = 3;
 
     auto additiveMetricsToCompare =
-        txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
+        txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
     additiveMetricsToCompare.add(CurOp::get(opCtx())->debug().additiveMetrics);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
-    ASSERT(txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
+    ASSERT(txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
         additiveMetricsToCompare));
 }
 
@@ -2537,37 +2203,35 @@ TEST_F(TransactionsMetricsTest, AdditiveMetricsObjectsShouldBeAddedTogetherUponA
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Initialize field values for both AdditiveMetrics objects.
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysExamined =
         2;
     CurOp::get(opCtx())->debug().additiveMetrics.keysExamined = 4;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.docsExamined =
         1;
     CurOp::get(opCtx())->debug().additiveMetrics.docsExamined = 3;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 2;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 0;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nMatched = 2;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.nModified = 0;
     CurOp::get(opCtx())->debug().additiveMetrics.nModified = 3;
     CurOp::get(opCtx())->debug().additiveMetrics.ndeleted = 5;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysInserted =
         1;
     CurOp::get(opCtx())->debug().additiveMetrics.keysInserted = 1;
-    txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysDeleted =
-        6;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.keysDeleted = 6;
     CurOp::get(opCtx())->debug().additiveMetrics.keysDeleted = 0;
-    txnParticipant->getSingleTransactionStatsForTest()
-        .getOpDebug()
-        ->additiveMetrics.writeConflicts = 3;
+    txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.writeConflicts =
+        3;
     CurOp::get(opCtx())->debug().additiveMetrics.writeConflicts = 3;
 
     auto additiveMetricsToCompare =
-        txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
+        txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics;
     additiveMetricsToCompare.add(CurOp::get(opCtx())->debug().additiveMetrics);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
 
-    ASSERT(txnParticipant->getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
+    ASSERT(txnParticipant.getSingleTransactionStatsForTest().getOpDebug()->additiveMetrics.equals(
         additiveMetricsToCompare));
 }
 
@@ -2579,33 +2243,33 @@ TEST_F(TransactionsMetricsTest, TimeInactiveMicrosShouldBeSetUponUnstashAndStash
 
     // Time inactive should have increased.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
     // Time inactive should have increased again.
     tickSource->advance(Microseconds(100));
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{200});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     tickSource->advance(Microseconds(100));
 
     // The transaction is currently active, so time inactive should not have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{200});
 
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     tickSource->advance(Microseconds(100));
 
     // The transaction is inactive again, so time inactive should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{300});
 }
@@ -2617,28 +2281,28 @@ TEST_F(TransactionsMetricsTest, TimeInactiveMicrosShouldBeSetUponUnstashAndAbort
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time inactive should be greater than or equal to zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 
     tickSource->advance(Microseconds(100));
 
     // Time inactive should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
 
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
     tickSource->advance(Microseconds(100));
 
     // The transaction has aborted, so time inactive should not have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 }
@@ -2650,26 +2314,26 @@ TEST_F(TransactionsMetricsTest, TimeInactiveMicrosShouldIncreaseUntilCommit) {
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
     // Time inactive should be greater than or equal to zero.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{0});
 
     tickSource->advance(Microseconds(100));
 
     // Time inactive should have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     tickSource->advance(Microseconds(100));
 
     // The transaction has committed, so time inactive should not have increased.
-    ASSERT_EQ(txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
+    ASSERT_EQ(txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(
                   tickSource, tickSource->getTicks()),
               Microseconds{100});
 }
@@ -2714,12 +2378,12 @@ TEST_F(TransactionsMetricsTest, ReportStashedResources) {
 
     // Perform initial unstash which sets up a WriteUnitOfWork.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
     ASSERT(opCtx()->getWriteUnitOfWork());
     ASSERT(opCtx()->lockState()->isLocked());
 
     // Prepare the transaction and extend the duration in the prepared state.
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
@@ -2727,11 +2391,11 @@ TEST_F(TransactionsMetricsTest, ReportStashedResources) {
     tickSource->advance(Microseconds(preparedDuration));
 
     // Stash resources. The original Locker and RecoveryUnit now belong to the stash.
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT(!opCtx()->getWriteUnitOfWork());
 
     // Verify that the Session's report of its own stashed state aligns with our expectations.
-    auto stashedState = txnParticipant->reportStashedState();
+    auto stashedState = txnParticipant.reportStashedState(opCtx());
     auto transactionDocument = stashedState.getObjectField("transaction");
     auto parametersDocument = transactionDocument.getObjectField("parameters");
 
@@ -2772,14 +2436,14 @@ TEST_F(TransactionsMetricsTest, ReportStashedResources) {
 
     // Unstash the stashed resources. This restores the original Locker and RecoveryUnit to the
     // OperationContext.
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
     ASSERT(opCtx()->getWriteUnitOfWork());
 
     // With the resources unstashed, verify that the Session reports an empty stashed state.
-    ASSERT(txnParticipant->reportStashedState().isEmpty());
+    ASSERT(txnParticipant.reportStashedState(opCtx()).isEmpty());
 
     // Commit the transaction. This allows us to release locks.
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
 }
 
 TEST_F(TransactionsMetricsTest, ReportUnstashedResources) {
@@ -2804,18 +2468,18 @@ TEST_F(TransactionsMetricsTest, ReportUnstashedResources) {
 
     // Perform initial unstash which sets up a WriteUnitOfWork.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
     ASSERT(opCtx()->getWriteUnitOfWork());
     ASSERT(opCtx()->lockState()->isLocked());
 
     // Prepare transaction and extend duration in the prepared state.
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.prepareTransaction(opCtx(), {});
     const long prepareDuration = 10;
     tickSource->advance(Microseconds(prepareDuration));
 
     // Verify that the Session's report of its own unstashed state aligns with our expectations.
     BSONObjBuilder unstashedStateBuilder;
-    txnParticipant->reportUnstashedState(opCtx(), &unstashedStateBuilder);
+    txnParticipant.reportUnstashedState(opCtx(), &unstashedStateBuilder);
     auto unstashedState = unstashedStateBuilder.obj();
     auto transactionDocument = unstashedState.getObjectField("transaction");
     auto parametersDocument = transactionDocument.getObjectField("parameters");
@@ -2842,12 +2506,12 @@ TEST_F(TransactionsMetricsTest, ReportUnstashedResources) {
     ASSERT_GTE(transactionDocument.getField("timeInactiveMicros").numberLong(), 0);
 
     // Stash resources. The original Locker and RecoveryUnit now belong to the stash.
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     ASSERT(!opCtx()->getWriteUnitOfWork());
 
     // With the resources stashed, verify that the Session reports an empty unstashed state.
     BSONObjBuilder builder;
-    txnParticipant->reportUnstashedState(opCtx(), &builder);
+    txnParticipant.reportUnstashedState(opCtx(), &builder);
     ASSERT(builder.obj().isEmpty());
 }
 
@@ -2857,8 +2521,8 @@ TEST_F(TransactionsMetricsTest, ReportUnstashedResourcesForARetryableWrite) {
 
     MongoDOperationContextSession opCtxSession(opCtx());
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->beginOrContinue(*opCtx()->getTxnNumber(), boost::none, boost::none);
-    txnParticipant->unstashTransactionResources(opCtx(), "find");
+    txnParticipant.beginOrContinue(opCtx(), *opCtx()->getTxnNumber(), boost::none, boost::none);
+    txnParticipant.unstashTransactionResources(opCtx(), "find");
 
     // Build a BSONObj containing the details which we expect to see reported when we invoke
     // reportUnstashedState. For a retryable write, we should only include the txnNumber.
@@ -2871,7 +2535,7 @@ TEST_F(TransactionsMetricsTest, ReportUnstashedResourcesForARetryableWrite) {
 
     // Verify that the Session's report of its own unstashed state aligns with our expectations.
     BSONObjBuilder unstashedStateBuilder;
-    txnParticipant->reportUnstashedState(opCtx(), &unstashedStateBuilder);
+    txnParticipant.reportUnstashedState(opCtx(), &unstashedStateBuilder);
     ASSERT_BSONOBJ_EQ(unstashedStateBuilder.obj(), reportBuilder.obj());
 }
 
@@ -2904,13 +2568,13 @@ TEST_F(TransactionsMetricsTest, LastClientInfoShouldUpdateUponStash) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
 
     // LastClientInfo should have been set.
-    auto lastClientInfo = txnParticipant->getSingleTransactionStatsForTest().getLastClientInfo();
+    auto lastClientInfo = txnParticipant.getSingleTransactionStatsForTest().getLastClientInfo();
     ASSERT_EQ(lastClientInfo.clientHostAndPort, "");
     ASSERT_EQ(lastClientInfo.connectionId, 0);
     ASSERT_EQ(lastClientInfo.appName, "appName");
@@ -2922,11 +2586,11 @@ TEST_F(TransactionsMetricsTest, LastClientInfoShouldUpdateUponStash) {
     clientMetadataIsMasterState.setClientMetadata(opCtx()->getClient(),
                                                   std::move(newClientMetadata.getValue()));
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.stashTransactionResources(opCtx());
 
     // LastClientInfo's clientMetadata should have been updated to the new ClientMetadata object.
-    lastClientInfo = txnParticipant->getSingleTransactionStatsForTest().getLastClientInfo();
+    lastClientInfo = txnParticipant.getSingleTransactionStatsForTest().getLastClientInfo();
     ASSERT_EQ(lastClientInfo.appName, "newAppName");
     ASSERT_BSONOBJ_EQ(lastClientInfo.clientMetadata, newObj.getField("client").Obj());
 }
@@ -2941,13 +2605,13 @@ TEST_F(TransactionsMetricsTest, LastClientInfoShouldUpdateUponCommit) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     // The transaction machinery cannot store an empty locker.
     Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow);
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     // LastClientInfo should have been set.
-    auto lastClientInfo = txnParticipant->getSingleTransactionStatsForTest().getLastClientInfo();
+    auto lastClientInfo = txnParticipant.getSingleTransactionStatsForTest().getLastClientInfo();
     ASSERT_EQ(lastClientInfo.clientHostAndPort, "");
     ASSERT_EQ(lastClientInfo.connectionId, 0);
     ASSERT_EQ(lastClientInfo.appName, "appName");
@@ -2965,11 +2629,11 @@ TEST_F(TransactionsMetricsTest, LastClientInfoShouldUpdateUponAbort) {
 
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.abortActiveTransaction(opCtx());
 
     // LastClientInfo should have been set.
-    auto lastClientInfo = txnParticipant->getSingleTransactionStatsForTest().getLastClientInfo();
+    auto lastClientInfo = txnParticipant.getSingleTransactionStatsForTest().getLastClientInfo();
     ASSERT_EQ(lastClientInfo.clientHostAndPort, "");
     ASSERT_EQ(lastClientInfo.connectionId, 0);
     ASSERT_EQ(lastClientInfo.appName, "appName");
@@ -3023,33 +2687,33 @@ void buildSingleTransactionStatsString(StringBuilder* sb, const int metricValue)
  * Builds the time active and time inactive info string.
  */
 void buildTimeActiveInactiveString(StringBuilder* sb,
-                                   TransactionParticipant* txnParticipant,
+                                   TransactionParticipant::Participant txnParticipant,
                                    TickSource* tickSource,
                                    TickSource::Tick curTick) {
     // Add time active micros to string.
     (*sb) << " timeActiveMicros:"
           << durationCount<Microseconds>(
-                 txnParticipant->getSingleTransactionStatsForTest().getTimeActiveMicros(tickSource,
-                                                                                        curTick));
+                 txnParticipant.getSingleTransactionStatsForTest().getTimeActiveMicros(tickSource,
+                                                                                       curTick));
 
     // Add time inactive micros to string.
     (*sb) << " timeInactiveMicros:"
           << durationCount<Microseconds>(
-                 txnParticipant->getSingleTransactionStatsForTest().getTimeInactiveMicros(
-                     tickSource, curTick));
+                 txnParticipant.getSingleTransactionStatsForTest().getTimeInactiveMicros(tickSource,
+                                                                                         curTick));
 }
 
 /*
  * Builds the total prepared duration info string.
  */
 void buildPreparedDurationString(StringBuilder* sb,
-                                 TransactionParticipant* txnParticipant,
+                                 TransactionParticipant::Participant txnParticipant,
                                  TickSource* tickSource,
                                  TickSource::Tick curTick) {
     (*sb) << " totalPreparedDurationMicros:"
           << durationCount<Microseconds>(
-                 txnParticipant->getSingleTransactionStatsForTest().getPreparedDuration(tickSource,
-                                                                                        curTick));
+                 txnParticipant.getSingleTransactionStatsForTest().getPreparedDuration(tickSource,
+                                                                                       curTick));
 }
 
 /*
@@ -3057,7 +2721,7 @@ void buildPreparedDurationString(StringBuilder* sb,
  */
 std::string buildTransactionInfoString(
     OperationContext* opCtx,
-    TransactionParticipant* txnParticipant,
+    TransactionParticipant::Participant txnParticipant,
     std::string terminationCause,
     const LogicalSessionId sessionId,
     const TxnNumber txnNum,
@@ -3088,7 +2752,7 @@ std::string buildTransactionInfoString(
     StringBuilder readTimestampInfo;
     readTimestampInfo
         << " readTimestamp:"
-        << txnParticipant->getSpeculativeTransactionReadOpTimeForTest().getTimestamp().toString()
+        << txnParticipant.getSpeculativeTransactionReadOpTimeForTest().getTimestamp().toString()
         << ",";
 
     StringBuilder singleTransactionStatsInfo;
@@ -3129,24 +2793,24 @@ std::string buildTransactionInfoString(
         expectedTransactionInfo << totalPreparedDuration.str();
         expectedTransactionInfo << " prepareOpTime:"
                                 << (prepareOpTime ? prepareOpTime->toString()
-                                                  : txnParticipant->getPrepareOpTime().toString());
+                                                  : txnParticipant.getPrepareOpTime().toString());
     }
-    if (txnParticipant->getOldestOplogEntryOpTimeForTest()) {
+    if (txnParticipant.getOldestOplogEntryOpTimeForTest()) {
         ASSERT(!oldestOplogEntryOpTime);
         expectedTransactionInfo << " oldestOplogEntryOpTime:"
-                                << txnParticipant->getOldestOplogEntryOpTimeForTest()->toString();
+                                << txnParticipant.getOldestOplogEntryOpTimeForTest()->toString();
     }
     if (oldestOplogEntryOpTime) {
-        ASSERT(!txnParticipant->getOldestOplogEntryOpTimeForTest());
+        ASSERT(!txnParticipant.getOldestOplogEntryOpTimeForTest());
         expectedTransactionInfo << " oldestOplogEntryOpTime:" << oldestOplogEntryOpTime->toString();
     }
-    if (txnParticipant->getFinishOpTimeForTest()) {
+    if (txnParticipant.getFinishOpTimeForTest()) {
         expectedTransactionInfo << " finishOpTime:"
-                                << txnParticipant->getFinishOpTimeForTest()->toString();
+                                << txnParticipant.getFinishOpTimeForTest()->toString();
     }
     expectedTransactionInfo << ", "
                             << duration_cast<Milliseconds>(
-                                   txnParticipant->getSingleTransactionStatsForTest().getDuration(
+                                   txnParticipant.getSingleTransactionStatsForTest().getDuration(
                                        tickSource, tickSource->getTicks()));
     return expectedTransactionInfo.str();
 }
@@ -3169,13 +2833,13 @@ TEST_F(TransactionsMetricsTest, TestTransactionInfoForLogAfterCommit) {
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
-    std::string testTransactionInfo =
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, true, readConcernArgs);
+    std::string testTransactionInfo = txnParticipant.getTransactionInfoForLogForTest(
+        opCtx(), &lockerInfo->stats, true, readConcernArgs);
 
     std::string expectedTransactionInfo =
         buildTransactionInfoString(opCtx(),
@@ -3209,19 +2873,19 @@ TEST_F(TransactionsMetricsTest, TestPreparedTransactionInfoForLogAfterCommit) {
 
     // Prepare the transaction and extend the duration in the prepared state.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     tickSource->advance(Microseconds(10));
 
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
-    std::string testTransactionInfo =
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, true, readConcernArgs);
+    std::string testTransactionInfo = txnParticipant.getTransactionInfoForLogForTest(
+        opCtx(), &lockerInfo->stats, true, readConcernArgs);
 
     std::string expectedTransactionInfo =
         buildTransactionInfoString(opCtx(),
@@ -3252,14 +2916,14 @@ TEST_F(TransactionsMetricsTest, TestTransactionInfoForLogAfterAbort) {
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.abortActiveTransaction(opCtx());
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
 
-    std::string testTransactionInfo =
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, false, readConcernArgs);
+    std::string testTransactionInfo = txnParticipant.getTransactionInfoForLogForTest(
+        opCtx(), &lockerInfo->stats, false, readConcernArgs);
 
     std::string expectedTransactionInfo =
         buildTransactionInfoString(opCtx(),
@@ -3293,17 +2957,17 @@ TEST_F(TransactionsMetricsTest, TestPreparedTransactionInfoForLogAfterAbort) {
 
     // Prepare the transaction and extend the duration in the prepared state.
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
     tickSource->advance(Microseconds(10));
 
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
 
-    std::string testTransactionInfo =
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, false, readConcernArgs);
+    std::string testTransactionInfo = txnParticipant.getTransactionInfoForLogForTest(
+        opCtx(), &lockerInfo->stats, false, readConcernArgs);
 
     std::string expectedTransactionInfo =
         buildTransactionInfoString(opCtx(),
@@ -3334,10 +2998,10 @@ DEATH_TEST_F(TransactionsMetricsTest, TestTransactionInfoForLogWithNoLockerInfoS
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.commitUnpreparedTransaction(opCtx());
 
-    txnParticipant->getTransactionInfoForLogForTest(nullptr, true, readConcernArgs);
+    txnParticipant.getTransactionInfoForLogForTest(opCtx(), nullptr, true, readConcernArgs);
 }
 
 TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterSlowCommit) {
@@ -3359,19 +3023,20 @@ TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterSlowCommit) {
     const int metricValue = 1;
     setupAdditiveMetrics(metricValue, opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
 
     serverGlobalParams.slowMS = 10;
     tickSource->advance(Microseconds(11 * 1000));
 
     startCapturingLogMessages();
-    txnParticipant->commitUnpreparedTransaction(opCtx());
+    txnParticipant.commitUnpreparedTransaction(opCtx());
     stopCapturingLogMessages();
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
     std::string expectedTransactionInfo = "transaction " +
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, true, readConcernArgs);
+        txnParticipant.getTransactionInfoForLogForTest(
+            opCtx(), &lockerInfo->stats, true, readConcernArgs);
     ASSERT_EQUALS(1, countLogLinesContaining(expectedTransactionInfo));
 }
 
@@ -3397,19 +3062,20 @@ TEST_F(TransactionsMetricsTest, LogPreparedTransactionInfoAfterSlowCommit) {
     serverGlobalParams.slowMS = 10;
     tickSource->advance(Microseconds(11 * 1000));
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
 
     startCapturingLogMessages();
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
     stopCapturingLogMessages();
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
     ASSERT(lockerInfo);
     std::string expectedTransactionInfo = "transaction " +
-        txnParticipant->getTransactionInfoForLogForTest(&lockerInfo->stats, true, readConcernArgs);
+        txnParticipant.getTransactionInfoForLogForTest(
+            opCtx(), &lockerInfo->stats, true, readConcernArgs);
     ASSERT_EQUALS(1, countLogLinesContaining(expectedTransactionInfo));
 }
 
@@ -3432,13 +3098,13 @@ TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterSlowAbort) {
     const int metricValue = 1;
     setupAdditiveMetrics(metricValue, opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
 
     serverGlobalParams.slowMS = 10;
     tickSource->advance(Microseconds(11 * 1000));
 
     startCapturingLogMessages();
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
     stopCapturingLogMessages();
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
@@ -3475,15 +3141,15 @@ TEST_F(TransactionsMetricsTest, LogPreparedTransactionInfoAfterSlowAbort) {
     const int metricValue = 1;
     setupAdditiveMetrics(metricValue, opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
 
     serverGlobalParams.slowMS = 10;
     tickSource->advance(Microseconds(11 * 1000));
-    auto prepareOpTime = txnParticipant->getPrepareOpTime();
+    auto prepareOpTime = txnParticipant.getPrepareOpTime();
 
     startCapturingLogMessages();
-    txnParticipant->abortActiveTransaction(opCtx());
+    txnParticipant.abortActiveTransaction(opCtx());
     stopCapturingLogMessages();
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
@@ -3522,18 +3188,18 @@ TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterExceptionInPrepare) {
     const int metricValue = 1;
     setupAdditiveMetrics(metricValue, opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
     serverGlobalParams.slowMS = 10;
     tickSource->advance(Microseconds(11 * 1000));
 
     _opObserver->onTransactionPrepareThrowsException = true;
 
     startCapturingLogMessages();
-    ASSERT_THROWS_CODE(txnParticipant->prepareTransaction(opCtx(), {}),
+    ASSERT_THROWS_CODE(txnParticipant.prepareTransaction(opCtx(), {}),
                        AssertionException,
                        ErrorCodes::OperationFailed);
     ASSERT_FALSE(_opObserver->transactionPrepared);
-    ASSERT(txnParticipant->transactionIsAborted());
+    ASSERT(txnParticipant.transactionIsAborted());
     stopCapturingLogMessages();
 
     const auto lockerInfo = opCtx()->lockState()->getLockerInfo(boost::none);
@@ -3569,12 +3235,12 @@ TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterSlowStashedAbort) {
     const int metricValue = 1;
     setupAdditiveMetrics(metricValue, opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
 
     { Lock::GlobalLock lk(opCtx(), MODE_IX, Date_t::now(), Lock::InterruptBehavior::kThrow); }
 
-    txnParticipant->stashTransactionResources(opCtx());
-    const auto txnResourceStashLocker = txnParticipant->getTxnResourceStashLockerForTest();
+    txnParticipant.stashTransactionResources(opCtx());
+    const auto txnResourceStashLocker = txnParticipant.getTxnResourceStashLockerForTest();
     ASSERT(txnResourceStashLocker);
     const auto lockerInfo = txnResourceStashLocker->getLockerInfo(boost::none);
 
@@ -3582,7 +3248,7 @@ TEST_F(TransactionsMetricsTest, LogTransactionInfoAfterSlowStashedAbort) {
     tickSource->advance(Microseconds(11 * 1000));
 
     startCapturingLogMessages();
-    txnParticipant->abortArbitraryTransaction();
+    txnParticipant.abortTransactionIfNotPrepared(opCtx());
     stopCapturingLogMessages();
 
     std::string expectedTransactionInfo = "transaction parameters";
@@ -3596,17 +3262,17 @@ TEST_F(TxnParticipantTest, WhenOldestTSRemovedNextOldestBecomesNewOldest) {
     // Check that there are no Timestamps in the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 0U);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    auto firstPrepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    auto firstPrepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     // Check that we added a Timestamp to the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
     // Check that the oldest prepareTimestamp is equal to firstPrepareTimestamp because there is
     // only one prepared transaction on this Service.
     auto prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), firstPrepareTimestamp);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
 
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     auto originalClient = Client::releaseCurrent();
 
     /**
@@ -3628,19 +3294,19 @@ TEST_F(TxnParticipantTest, WhenOldestTSRemovedNextOldestBecomesNewOldest) {
 
         MongoDOperationContextSession newOpCtxSession(newOpCtx.get());
         auto newTxnParticipant = TransactionParticipant::get(newOpCtx.get());
-        newTxnParticipant->beginOrContinue(newTxnNum, false, true);
-        newTxnParticipant->unstashTransactionResources(newOpCtx.get(), "prepareTransaction");
+        newTxnParticipant.beginOrContinue(newOpCtx.get(), newTxnNum, false, true);
+        newTxnParticipant.unstashTransactionResources(newOpCtx.get(), "prepareTransaction");
 
         // secondPrepareTimestamp should be greater than firstPreparedTimestamp because this
         // transaction was prepared after.
-        secondPrepareTimestamp = newTxnParticipant->prepareTransaction(newOpCtx.get(), {});
+        secondPrepareTimestamp = newTxnParticipant.prepareTransaction(newOpCtx.get(), {});
         ASSERT_GT(secondPrepareTimestamp, firstPrepareTimestamp);
         // Check that we added a Timestamp to the set.
         ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 2U);
         // The oldest prepareTimestamp should still be firstPrepareTimestamp.
         prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
         ASSERT_EQ(prepareOpTime->getTimestamp(), firstPrepareTimestamp);
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
+        ASSERT_FALSE(txnParticipant.transactionIsAborted());
     }
 
     Client::releaseCurrent();
@@ -3648,9 +3314,9 @@ TEST_F(TxnParticipantTest, WhenOldestTSRemovedNextOldestBecomesNewOldest) {
 
     // Switch clients and abort the first transaction. This should cause the oldestActiveTS to be
     // equal to the secondPrepareTimestamp.
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
     prepareOpTime = ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime();
     ASSERT_EQ(prepareOpTime->getTimestamp(), secondPrepareTimestamp);
@@ -3663,13 +3329,13 @@ TEST_F(TxnParticipantTest, ReturnNullTimestampIfNoOldestActiveTimestamp) {
     // Check that there are no Timestamps in the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 0U);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.prepareTransaction(opCtx(), {});
     // Check that we added a Timestamp to the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
 
-    txnParticipant->stashTransactionResources(opCtx());
+    txnParticipant.stashTransactionResources(opCtx());
     auto originalClient = Client::releaseCurrent();
 
     /**
@@ -3690,20 +3356,20 @@ TEST_F(TxnParticipantTest, ReturnNullTimestampIfNoOldestActiveTimestamp) {
 
         MongoDOperationContextSession newOpCtxSession(newOpCtx.get());
         auto newTxnParticipant = TransactionParticipant::get(newOpCtx.get());
-        newTxnParticipant->beginOrContinue(newTxnNum, false, true);
-        newTxnParticipant->unstashTransactionResources(newOpCtx.get(), "prepareTransaction");
+        newTxnParticipant.beginOrContinue(newOpCtx.get(), newTxnNum, false, true);
+        newTxnParticipant.unstashTransactionResources(newOpCtx.get(), "prepareTransaction");
 
         // secondPrepareTimestamp should be greater than firstPreparedTimestamp because this
         // transaction was prepared after.
-        newTxnParticipant->prepareTransaction(newOpCtx.get(), {});
+        newTxnParticipant.prepareTransaction(newOpCtx.get(), {});
         // Check that we added a Timestamp to the set.
         ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 2U);
         // The oldest prepareTimestamp should still be firstPrepareTimestamp.
-        ASSERT_FALSE(txnParticipant->transactionIsAborted());
+        ASSERT_FALSE(txnParticipant.transactionIsAborted());
 
         // Abort this transaction and check that we have decremented the total active timestamps
         // count.
-        newTxnParticipant->abortActiveTransaction(newOpCtx.get());
+        newTxnParticipant.abortActiveTransaction(newOpCtx.get());
         ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
     }
 
@@ -3712,9 +3378,9 @@ TEST_F(TxnParticipantTest, ReturnNullTimestampIfNoOldestActiveTimestamp) {
 
     // Switch clients and abort the first transaction. This means we no longer have an oldest active
     // timestamp.
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 0U);
     ASSERT_FALSE(ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime());
 }
@@ -3726,8 +3392,8 @@ TEST_F(TxnParticipantTest, ProperlyMaintainOldestNonMajorityCommittedOpTimeSet)
     // Check that there are no Timestamps in the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 0U);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "prepareTransaction");
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    txnParticipant.unstashTransactionResources(opCtx(), "prepareTransaction");
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
     // Check that we added a Timestamp to the set.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
 
@@ -3746,14 +3412,14 @@ TEST_F(TxnParticipantTest, ProperlyMaintainOldestNonMajorityCommittedOpTimeSet)
         ServerTransactionsMetrics::get(opCtx())->getFinishOpTimeOfOldestNonMajCommitted_forTest();
     ASSERT_EQ(nonMajorityCommittedOpTimeFinishOpTime->getTimestamp(), Timestamp::max());
 
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
     // Since this test uses a mock opObserver, we have to manually set the finishTimestamp on the
     // txnParticipant.
     auto finishOpTime = repl::OpTime({10, 10}, 0);
     repl::ReplClientInfo::forClient(opCtx()->getClient()).setLastOp(finishOpTime);
 
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT(txnParticipant->transactionIsAborted());
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT(txnParticipant.transactionIsAborted());
 
     // Make sure that we moved the OpTime from the oldestActiveOplogEntryOpTimes to
     // oldestNonMajorityCommittedOpTimes along with the abort/commit oplog entry OpTime
@@ -3860,13 +3526,13 @@ TEST_F(TxnParticipantTest, RollbackResetsInMemoryStateOfPreparedTransaction) {
     ASSERT_FALSE(ServerTransactionsMetrics::get(opCtx())->getOldestNonMajorityCommittedOpTime());
 
     // Perform an insert as a part of a transaction so that we have a transaction operation.
-    txnParticipant->unstashTransactionResources(opCtx(), "insert");
+    txnParticipant.unstashTransactionResources(opCtx(), "insert");
     auto operation = repl::OplogEntry::makeInsertOperation(kNss, kUUID, BSON("TestValue" << 0));
-    txnParticipant->addTransactionOperation(opCtx(), operation);
+    txnParticipant.addTransactionOperation(opCtx(), operation);
     ASSERT_BSONOBJ_EQ(operation.toBSON(),
-                      txnParticipant->getTransactionOperationsForTest()[0].toBSON());
+                      txnParticipant.getTransactionOperationsForTest()[0].toBSON());
 
-    auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), {});
+    auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), {});
 
     // Check that we added a Timestamp to oldestActiveOplogEntryOpTimes.
     ASSERT_EQ(ServerTransactionsMetrics::get(opCtx())->getTotalActiveOpTimes(), 1U);
@@ -3878,23 +3544,23 @@ TEST_F(TxnParticipantTest, RollbackResetsInMemoryStateOfPreparedTransaction) {
         ServerTransactionsMetrics::get(opCtx())->getOldestNonMajorityCommittedOpTime();
     ASSERT_EQ(oldestActiveOpTime->getTimestamp(), prepareTimestamp);
     ASSERT_EQ(oldestNonMajorityCommittedOpTime->getTimestamp(), prepareTimestamp);
-    ASSERT_FALSE(txnParticipant->transactionIsAborted());
+    ASSERT_FALSE(txnParticipant.transactionIsAborted());
 
     // Make sure the state of txnParticipant is populated correctly after a prepared transaction.
-    ASSERT(txnParticipant->transactionIsPrepared());
-    ASSERT_EQ(txnParticipant->getTransactionOperationsForTest().size(), 1U);
-    ASSERT_EQ(txnParticipant->getPrepareOpTime().getTimestamp(), prepareTimestamp);
-    ASSERT_NE(txnParticipant->getActiveTxnNumber(), kUninitializedTxnNumber);
+    ASSERT(txnParticipant.transactionIsPrepared());
+    ASSERT_EQ(txnParticipant.getTransactionOperationsForTest().size(), 1U);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime().getTimestamp(), prepareTimestamp);
+    ASSERT_NE(txnParticipant.getActiveTxnNumber(), kUninitializedTxnNumber);
 
-    txnParticipant->abortPreparedTransactionForRollback();
+    txnParticipant.abortPreparedTransactionForRollback(opCtx());
     ServerTransactionsMetrics::get(opCtx())->clearOpTimes();
 
     // After calling abortPreparedTransactionForRollback, the state of txnParticipant should be
     // invalidated.
-    ASSERT_FALSE(txnParticipant->transactionIsPrepared());
-    ASSERT_EQ(txnParticipant->getTransactionOperationsForTest().size(), 0U);
-    ASSERT_EQ(txnParticipant->getPrepareOpTime().getTimestamp(), Timestamp());
-    ASSERT_EQ(txnParticipant->getActiveTxnNumber(), kUninitializedTxnNumber);
+    ASSERT_FALSE(txnParticipant.transactionIsPrepared());
+    ASSERT_EQ(txnParticipant.getTransactionOperationsForTest().size(), 0U);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime().getTimestamp(), Timestamp());
+    ASSERT_EQ(txnParticipant.getActiveTxnNumber(), kUninitializedTxnNumber);
 
     // After calling clearOpTimes, we should no longer have an oldestActiveOpTime.
     ASSERT_FALSE(ServerTransactionsMetrics::get(opCtx())->getOldestActiveOpTime());
@@ -3907,18 +3573,18 @@ TEST_F(TxnParticipantTest, PrepareTransactionAsSecondarySetsThePrepareOpTime) {
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), prepareOpTime);
-    ASSERT(txnParticipant->transactionIsPrepared());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), prepareOpTime);
+    ASSERT(txnParticipant.transactionIsPrepared());
     ASSERT_EQ(prepareTimestamp, prepareOpTime.getTimestamp());
-    ASSERT_EQ(txnParticipant->getPrepareOpTime(), prepareOpTime);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime(), prepareOpTime);
 
     // If _prepareOptime was not set and was null, then commitPreparedTransaction would falsely
     // succeed everytime. We set the commitTimestamp to be less than the prepareTimestamp to make
     // sure this is not the case.
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() - 1);
-    ASSERT_THROWS_CODE(txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {}),
+    ASSERT_THROWS_CODE(txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {}),
                        AssertionException,
                        ErrorCodes::InvalidOptions);
 }
@@ -3932,18 +3598,18 @@ TEST_F(TxnParticipantTest, CommitPreparedTransactionAsSecondarySetsTheFinishOpTi
     repl::UnreplicatedWritesBlock uwb(opCtx());
     ASSERT(!opCtx()->writesAreReplicated());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), prepareOpTime);
-    ASSERT(txnParticipant->transactionIsPrepared());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), prepareOpTime);
+    ASSERT(txnParticipant.transactionIsPrepared());
     ASSERT_EQ(prepareTimestamp, prepareOpTime.getTimestamp());
-    ASSERT_EQ(txnParticipant->getPrepareOpTime(), prepareOpTime);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime(), prepareOpTime);
 
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
     const auto commitOplogEntryOpTime = repl::OpTime({10, 10}, 0);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, commitOplogEntryOpTime);
-    ASSERT_EQ(txnParticipant->getFinishOpTimeForTest().get(), commitOplogEntryOpTime);
-    ASSERT_TRUE(txnParticipant->transactionIsCommitted());
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, commitOplogEntryOpTime);
+    ASSERT_EQ(txnParticipant.getFinishOpTimeForTest().get(), commitOplogEntryOpTime);
+    ASSERT_TRUE(txnParticipant.transactionIsCommitted());
 }
 
 DEATH_TEST_F(TxnParticipantTest,
@@ -3957,15 +3623,15 @@ DEATH_TEST_F(TxnParticipantTest,
     repl::UnreplicatedWritesBlock uwb(opCtx());
     ASSERT(!opCtx()->writesAreReplicated());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), prepareOpTime);
-    ASSERT(txnParticipant->transactionIsPrepared());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), prepareOpTime);
+    ASSERT(txnParticipant.transactionIsPrepared());
     ASSERT_EQ(prepareTimestamp, prepareOpTime.getTimestamp());
-    ASSERT_EQ(txnParticipant->getPrepareOpTime(), prepareOpTime);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime(), prepareOpTime);
 
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, {});
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, {});
 }
 
 DEATH_TEST_F(TxnParticipantTest,
@@ -3975,16 +3641,16 @@ DEATH_TEST_F(TxnParticipantTest,
     auto sessionCheckout = checkOutSession();
     auto txnParticipant = TransactionParticipant::get(opCtx());
 
-    txnParticipant->unstashTransactionResources(opCtx(), "commitTransaction");
-    const auto prepareTimestamp = txnParticipant->prepareTransaction(opCtx(), prepareOpTime);
-    ASSERT(txnParticipant->transactionIsPrepared());
+    txnParticipant.unstashTransactionResources(opCtx(), "commitTransaction");
+    const auto prepareTimestamp = txnParticipant.prepareTransaction(opCtx(), prepareOpTime);
+    ASSERT(txnParticipant.transactionIsPrepared());
     ASSERT_EQ(prepareTimestamp, prepareOpTime.getTimestamp());
-    ASSERT_EQ(txnParticipant->getPrepareOpTime(), prepareOpTime);
+    ASSERT_EQ(txnParticipant.getPrepareOpTime(), prepareOpTime);
 
     const auto commitTimestamp =
         Timestamp(prepareTimestamp.getSecs(), prepareTimestamp.getInc() + 1);
     const auto commitOplogEntryOpTime = repl::OpTime({10, 10}, 0);
-    txnParticipant->commitPreparedTransaction(opCtx(), commitTimestamp, commitOplogEntryOpTime);
+    txnParticipant.commitPreparedTransaction(opCtx(), commitTimestamp, commitOplogEntryOpTime);
 }
 
 TEST_F(TxnParticipantTest, AbortTransactionOnSessionCheckoutWithoutRefresh) {
@@ -4004,12 +3670,12 @@ TEST_F(TxnParticipantTest, AbortTransactionOnSessionCheckoutWithoutRefresh) {
     MongoDOperationContextSessionWithoutRefresh sessionCheckout(opCtx());
 
     auto txnParticipant = TransactionParticipant::get(opCtx());
-    ASSERT(txnParticipant->inMultiDocumentTransaction());
-    ASSERT_EQ(txnParticipant->getActiveTxnNumber(), txnNumber);
+    ASSERT(txnParticipant.inMultiDocumentTransaction());
+    ASSERT_EQ(txnParticipant.getActiveTxnNumber(), txnNumber);
 
-    txnParticipant->unstashTransactionResources(opCtx(), "abortTransaction");
-    txnParticipant->abortActiveTransaction(opCtx());
-    ASSERT_TRUE(txnParticipant->transactionIsAborted());
+    txnParticipant.unstashTransactionResources(opCtx(), "abortTransaction");
+    txnParticipant.abortActiveTransaction(opCtx());
+    ASSERT_TRUE(txnParticipant.transactionIsAborted());
 }
 
 }  // namespace