SERVER-63491 Remove TxnNumberAndRetryCounter as a parameter for txnRouter.beginOrContinue()

11 files changed, 364 insertions, 1245 deletions

diff --git a/jstests/noPassthrough/transaction_coordinator_curop_info.js b/jstests/noPassthrough/transaction_coordinator_curop_info.js
index 24ac4bb09a8..be2e66a7568 100644
--- a/jstests/noPassthrough/transaction_coordinator_curop_info.js
+++ b/jstests/noPassthrough/transaction_coordinator_curop_info.js
@@ -12,18 +12,13 @@
 load('jstests/libs/fail_point_util.js');
 load('jstests/sharding/libs/sharded_transactions_helpers.js');  // for waitForFailpoint
 
-function commitTxn(
-    st, lsid, txnNumber, txnRetryCounter, areInternalTransactionsEnabled, expectedError = null) {
-    const txnRetryCounterField = areInternalTransactionsEnabled
-        ? ("txnRetryCounter: NumberInt(" + txnRetryCounter + "),")
-        : "";
-
+function commitTxn(st, lsid, txnNumber, expectedError = null) {
     let cmd = "db.adminCommand({" +
         "commitTransaction: 1," +
         "lsid: " + tojson(lsid) + "," +
         "txnNumber: NumberLong(" + txnNumber + ")," +
         "stmtId: NumberInt(0)," +
-        "autocommit: false," + txnRetryCounterField + "})";
+        "autocommit: false})";
 
     if (expectedError) {
         cmd = "assert.commandFailedWithCode(" + cmd + "," + String(expectedError) + ");";
@@ -85,7 +80,7 @@ function enableFailPoints(shard, failPointNames) {
     return failPoints;
 }
 
-function startTransaction(session, collectionName, insertValue, areInternalTransactionsEnabled) {
+function startTransaction(session, collectionName, insertValue) {
     const dbName = session.getDatabase('test');
     jsTest.log(`Starting a new transaction on ${dbName}.${collectionName}`);
     var insertCmdObj = {
@@ -97,10 +92,6 @@ function startTransaction(session, collectionName, insertValue, areInternalTrans
         autocommit: false,
     };
 
-    if (areInternalTransactionsEnabled) {
-        Object.assign(insertCmdObj, {txnRetryCounter: NumberInt(1)});
-    }
-
     assert.commandWorked(dbName.runCommand(insertCmdObj));
 }
 
@@ -140,12 +131,11 @@ let failPoints = enableFailPoints(coordinator, failPointNames);
 jsTest.log("Testing that coordinator threads show up in currentOp for a commit decision");
 {
     let session = adminDB.getMongo().startSession();
-    startTransaction(session, collectionName, 1, areInternalTransactionsEnabled);
+    startTransaction(session, collectionName, 1);
     let txnNumber = NumberLong(1);
-    let txnRetryCounter = NumberInt(1);
+    let txnRetryCounter = NumberInt(0);
     let lsid = session.getSessionId();
-    let commitJoin =
-        commitTxn(st, lsid, txnNumber, txnRetryCounter, areInternalTransactionsEnabled);
+    let commitJoin = commitTxn(st, lsid, txnNumber);
 
     var coordinateCommitFilter = {
         active: true,
@@ -156,10 +146,6 @@ jsTest.log("Testing that coordinator threads show up in currentOp for a commit d
         'command.autocommit': false
     };
 
-    if (areInternalTransactionsEnabled) {
-        Object.assign(coordinateCommitFilter, {'command.txnRetryCounter': txnRetryCounter});
-    }
-
     let createCoordinateCommitTxnOp = curOpAfterFailpoint(
         failPoints["hangAfterStartingCoordinateCommit"], coordinateCommitFilter);
     assert.eq(1, createCoordinateCommitTxnOp.length);
@@ -200,10 +186,10 @@ jsTest.log("Testing that coordinator threads show up in currentOp for a commit d
 jsTest.log("Testing that coordinator threads show up in currentOp for an abort decision.");
 {
     let session = adminDB.getMongo().startSession();
-    startTransaction(session, collectionName, 2, areInternalTransactionsEnabled);
+    startTransaction(session, collectionName, 2);
     let txnNumber = NumberLong(1);
     let lsid = session.getSessionId();
-    let txnRetryCounter = NumberInt(1);
+    let txnRetryCounter = NumberInt(0);
     // Manually abort the transaction on one of the participants, so that the participant fails to
     // prepare and failpoint is triggered on the coordinator.
     var abortTransactionCmd = {
@@ -214,18 +200,9 @@ jsTest.log("Testing that coordinator threads show up in currentOp for an abort d
         autocommit: false,
     };
 
-    if (areInternalTransactionsEnabled) {
-        Object.assign(abortTransactionCmd, {txnRetryCounter: txnRetryCounter});
-    }
-
     assert.commandWorked(participant.adminCommand(abortTransactionCmd));
 
-    let commitJoin = commitTxn(st,
-                               lsid,
-                               txnNumber,
-                               txnRetryCounter,
-                               areInternalTransactionsEnabled,
-                               ErrorCodes.NoSuchTransaction);
+    let commitJoin = commitTxn(st, lsid, txnNumber, ErrorCodes.NoSuchTransaction);
 
     const sendAbortFilter = makeWorkerFilterWithAction(
         session, "sendingAbort", txnNumber, txnRetryCounter, areInternalTransactionsEnabled);
@@ -237,4 +214,4 @@ jsTest.log("Testing that coordinator threads show up in currentOp for an abort d
 }
 
 st.stop();
-})();
\ No newline at end of file
+})();
diff --git a/jstests/sharding/internal_transactions_retry_aborted_prepared_transactions.js b/jstests/sharding/internal_transactions_retry_aborted_prepared_transactions.js
deleted file mode 100644
index 5c0ea071d63..00000000000
--- a/jstests/sharding/internal_transactions_retry_aborted_prepared_transactions.js
+++ /dev/null
@@ -1,179 +0,0 @@
-/**
- * Test that mongos can retry an aborted transaction that successfully prepared on a subset of the
- * participant shards using a higher txnRetryCounter.
- *
- * @tags: [requires_fcv_51, featureFlagInternalTransactions, uses_transactions,
- * uses_multi_shard_transaction]
- */
-(function() {
-'use strict';
-
-load("jstests/libs/fail_point_util.js");
-load("jstests/libs/parallelTester.js");
-load("jstests/sharding/libs/sharded_transactions_helpers.js");
-
-const st = new ShardingTest({
-    mongos: 2,
-    shards: 2,
-});
-const shard1Primary = st.rs1.getPrimary();
-enableCoordinateCommitReturnImmediatelyAfterPersistingDecision(st);
-
-const kDbName = "testDb";
-const kCollName = "testColl";
-const kNs = kDbName + "." + kCollName;
-
-assert.commandWorked(st.s0.adminCommand({enableSharding: kDbName}));
-st.ensurePrimaryShard(kDbName, st.shard0.shardName);
-assert.commandWorked(st.s0.adminCommand({shardCollection: kNs, key: {x: 1}}));
-
-// Make both shards have chunks for the collection so that two-phase commit is required.
-assert.commandWorked(st.s0.adminCommand({split: kNs, middle: {x: 0}}));
-assert.commandWorked(st.s0.adminCommand({moveChunk: kNs, find: {x: 0}, to: st.shard1.shardName}));
-
-// Do an insert to force a refresh so the transaction doesn't fail due to StaleConfig.
-assert.commandWorked(st.s0.getCollection(kNs).insert({x: 0}));
-
-const lsid = {
-    id: UUID()
-};
-
-const txnNumber0 = 0;
-let txnRetryCounter0 = 1;
-const insertCmdObj = {
-    insert: kCollName,
-    documents: [{x: -10}, {x: 10}],
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber0),
-    startTransaction: true,
-    autocommit: false,
-};
-const commitCmdObj = {
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber0),
-    autocommit: false
-};
-
-jsTest.log(
-    "Force the transaction to successfully prepare on one of the participant shards and then abort");
-configureFailPoint(shard1Primary,
-                   "failCommand",
-                   {
-                       failInternalCommands: true,
-                       failCommands: ["prepareTransaction"],
-                       errorCode: ErrorCodes.NoSuchTransaction,
-                   },
-                   {times: 1});
-const insertRes = assert.commandWorked(st.s0.getDB(kDbName).runCommand(
-    Object.assign({}, insertCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})));
-assert.commandFailedWithCode(st.s0.adminCommand(Object.assign(
-                                 {}, commitCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})),
-                             ErrorCodes.NoSuchTransaction);
-// Verify that the abort decision can be recovered from both the original mongos and and the other
-// mongos.
-assert.commandFailedWithCode(st.s0.adminCommand(Object.assign(
-                                 {}, commitCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})),
-                             ErrorCodes.NoSuchTransaction);
-assert.commandFailedWithCode(
-    st.s1.adminCommand(Object.assign(
-        {},
-        commitCmdObj,
-        {txnRetryCounter: NumberInt(txnRetryCounter0), recoveryToken: insertRes.recoveryToken})),
-    ErrorCodes.NoSuchTransaction);
-jsTest.log(
-    "Verify after the transaction aborted, retrying commitTransaction with mismatching txnRetryCounter fails");
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber0),
-    txnRetryCounter: NumberInt(txnRetryCounter0 - 1),
-    autocommit: false
-}),
-                             ErrorCodes.TxnRetryCounterTooOld);
-// Cannot recover commit decision without recoveryToken.
-txnRetryCounter0++;
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber0),
-    txnRetryCounter: NumberInt(txnRetryCounter0),
-    autocommit: false,
-}),
-                             50940);
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber0),
-    txnRetryCounter: NumberInt(txnRetryCounter0),
-    autocommit: false,
-    recoveryToken: insertRes.recoveryToken
-}),
-                             ErrorCodes.IllegalOperation);
-
-jsTest.log(
-    "Verify that the transaction can be retried and re-committed using a higher txnRetryCounter");
-txnRetryCounter0++;
-const retryInsertRes = assert.commandWorked(st.s0.getDB(kDbName).runCommand(
-    Object.assign({}, insertCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})));
-assert.commandWorked(st.s0.adminCommand(
-    Object.assign({}, commitCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})));
-// Verify that the commit decision can be recovered from both the original mongos and and the other
-// mongos.
-assert.commandWorked(st.s0.adminCommand(
-    Object.assign({}, commitCmdObj, {txnRetryCounter: NumberInt(txnRetryCounter0)})));
-assert.commandWorked(st.s1.adminCommand(Object.assign(
-    {},
-    commitCmdObj,
-    {txnRetryCounter: NumberInt(txnRetryCounter0), recoveryToken: retryInsertRes.recoveryToken})));
-
-jsTest.log(
-    "Verify that after the retry the client can run a transaction with a higher txnNumber that requires two-phase commit");
-const txnNumber1 = 1;
-const txnRetryCounter1 = 1;
-const updateRes = assert.commandWorked(st.s0.getDB(kDbName).runCommand({
-    update: kCollName,
-    updates: [{q: {x: -10}, u: {$set: {y: -10}}}, {q: {x: 10}, u: {$set: {y: 10}}}],
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber1),
-    txnRetryCounter: NumberInt(txnRetryCounter1),
-    startTransaction: true,
-    autocommit: false,
-}));
-assert.commandWorked(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber1),
-    txnRetryCounter: NumberInt(txnRetryCounter1),
-    autocommit: false
-}));
-jsTest.log(
-    "Verify after the transaction committed, retrying commitTransaction with mismatching txnRetryCounter fails");
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber1),
-    txnRetryCounter: NumberInt(txnRetryCounter1 - 1),
-    autocommit: false
-}),
-                             ErrorCodes.TxnRetryCounterTooOld);
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber1),
-    txnRetryCounter: NumberInt(txnRetryCounter1 + 1),
-    autocommit: false,
-}),
-                             ErrorCodes.IllegalOperation);
-assert.commandFailedWithCode(st.s0.adminCommand({
-    commitTransaction: 1,
-    lsid: lsid,
-    txnNumber: NumberLong(txnNumber1),
-    txnRetryCounter: NumberInt(txnRetryCounter1 + 1),
-    autocommit: false,
-    recoveryToken: updateRes.recoveryToken
-}),
-                             ErrorCodes.IllegalOperation);
-
-st.stop();
-})();
diff --git a/jstests/sharding/internal_transactions_retry_on_transient_transaction_error_basic.js b/jstests/sharding/internal_transactions_retry_on_transient_transaction_error_basic.js
index 85fc4d62bf3..9b7bc2f4cb6 100644
--- a/jstests/sharding/internal_transactions_retry_on_transient_transaction_error_basic.js
+++ b/jstests/sharding/internal_transactions_retry_on_transient_transaction_error_basic.js
@@ -1,7 +1,7 @@
 /*
- * Tests that a client can retry a transaction that failed with a transient transaction error by
- * attaching a higher txnRetryCounter, and that the txnRetryCounter is persisted correctly on all
- * nodes.
+ * Tests that a transaction that failed with a transient transaction error
+ * can be retried on a replica set and that its txnRetryCounter is persisted correctly
+ * on all nodes.
  *
  * @tags: [requires_fcv_51, featureFlagInternalTransactions]
  */
@@ -233,22 +233,6 @@ function testNoPersistenceOfDefaultTxnRetryCounter(
 }
 
 (() => {
-    jsTest.log("Test transactions in a sharded cluster");
-    const sessionUUID = UUID();
-    const lsid0 = {id: sessionUUID};
-    testCommitAfterRetry(mongosTestDB, lsid0, NumberLong(0));
-    testAbortAfterRetry(mongosTestDB, lsid0, NumberLong(1));
-
-    const lsid1 = {id: sessionUUID, txnNumber: NumberLong(2), txnUUID: UUID()};
-    testCommitAfterRetry(mongosTestDB, lsid1, NumberLong(0));
-    testAbortAfterRetry(mongosTestDB, lsid1, NumberLong(1));
-
-    const lsid2 = {id: sessionUUID, txnUUID: UUID()};
-    testCommitAfterRetry(mongosTestDB, lsid2, NumberLong(0));
-    testAbortAfterRetry(mongosTestDB, lsid2, NumberLong(1));
-})();
-
-(() => {
     jsTest.log("Test transactions in a replica set");
     const sessionUUID = UUID();
     const lsid0 = {id: sessionUUID};
diff --git a/src/mongo/s/commands/document_shard_key_update_util.cpp b/src/mongo/s/commands/document_shard_key_update_util.cpp
index fef91ffc45e..629c29ebca5 100644
--- a/src/mongo/s/commands/document_shard_key_update_util.cpp
+++ b/src/mongo/s/commands/document_shard_key_update_util.cpp
@@ -150,9 +150,7 @@ void startTransactionForShardKeyUpdate(OperationContext* opCtx) {
     auto txnNumber = opCtx->getTxnNumber();
     invariant(txnNumber);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(*txnNumber, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, *txnNumber, TransactionRouter::TransactionActions::kStart);
 }
 
 BSONObj commitShardKeyUpdateTransaction(OperationContext* opCtx) {
diff --git a/src/mongo/s/commands/strategy.cpp b/src/mongo/s/commands/strategy.cpp
index 668241285ce..8ad6fc25a61 100644
--- a/src/mongo/s/commands/strategy.cpp
+++ b/src/mongo/s/commands/strategy.cpp
@@ -629,9 +629,6 @@ Status ParseAndRunCommand::RunInvocation::_setup() {
         auto txnNumber = opCtx->getTxnNumber();
         invariant(txnNumber);
 
-        auto txnRetryCounter = opCtx->getTxnRetryCounter();
-        invariant(txnRetryCounter);
-
         auto transactionAction = ([&] {
             auto startTxnSetting = _parc->_osi->getStartTransaction();
             if (startTxnSetting && *startTxnSetting) {
@@ -646,8 +643,7 @@ Status ParseAndRunCommand::RunInvocation::_setup() {
         })();
 
         startTransaction = (transactionAction == TransactionRouter::TransactionActions::kStart);
-        txnRouter.beginOrContinueTxn(
-            opCtx, TxnNumberAndRetryCounter(*txnNumber, *txnRetryCounter), transactionAction);
+        txnRouter.beginOrContinueTxn(opCtx, *txnNumber, transactionAction);
     }
 
     bool supportsWriteConcern = invocation->supportsWriteConcern();
diff --git a/src/mongo/s/transaction_router.cpp b/src/mongo/s/transaction_router.cpp
index 578d979b10c..70a99dc4eb9 100644
--- a/src/mongo/s/transaction_router.cpp
+++ b/src/mongo/s/transaction_router.cpp
@@ -932,86 +932,43 @@ void TransactionRouter::Router::_setAtClusterTime(
     o(lk).atClusterTime->setTime(candidateTime, p().latestStmtId);
 }
 
-void TransactionRouter::Router::_beginOrContinueActiveTxnNumber(
-    OperationContext* opCtx,
-    TxnNumberAndRetryCounter txnNumberAndRetryCounter,
-    TransactionActions action) {
+void TransactionRouter::Router::_continueTxn(OperationContext* opCtx,
+                                             TxnNumberAndRetryCounter txnNumberAndRetryCounter,
+                                             TransactionActions action) {
     invariant(txnNumberAndRetryCounter.getTxnNumber() ==
               o().txnNumberAndRetryCounter.getTxnNumber());
+    switch (action) {
+        case TransactionActions::kStart: {
+            uassert(ErrorCodes::ConflictingOperationInProgress,
+                    str::stream() << "txnNumber " << o().txnNumberAndRetryCounter.getTxnNumber()
+                                  << " txnRetryCounter "
+                                  << o().txnNumberAndRetryCounter.getTxnRetryCounter()
+                                  << " for session " << _sessionId() << " already started",
+                    isInternalSessionForRetryableWrite(_sessionId()));
+            break;
+        }
+        case TransactionActions::kContinue: {
+            uassert(ErrorCodes::InvalidOptions,
+                    "Only the first command in a transaction may specify a readConcern",
+                    repl::ReadConcernArgs::get(opCtx).isEmpty());
 
-    if (txnNumberAndRetryCounter.getTxnRetryCounter() <
-        o().txnNumberAndRetryCounter.getTxnRetryCounter()) {
-        uasserted(TxnRetryCounterTooOldInfo(*o().txnNumberAndRetryCounter.getTxnRetryCounter()),
-                  str::stream() << "Cannot " << actionTypeToString(action) << " transaction "
-                                << txnNumberAndRetryCounter.getTxnNumber() << " on session "
-                                << _sessionId() << " using txnRetryCounter "
-                                << txnNumberAndRetryCounter.getTxnRetryCounter()
-                                << " because the transaction has already been restarted using"
-                                << " a higher txnRetryCounter "
-                                << o().txnNumberAndRetryCounter.getTxnRetryCounter());
-    } else if (txnNumberAndRetryCounter.getTxnRetryCounter() ==
-               o().txnNumberAndRetryCounter.getTxnRetryCounter()) {
-        switch (action) {
-            case TransactionActions::kStart: {
-                uassert(ErrorCodes::ConflictingOperationInProgress,
-                        str::stream() << "txnNumber " << o().txnNumberAndRetryCounter.getTxnNumber()
-                                      << " txnRetryCounter "
-                                      << o().txnNumberAndRetryCounter.getTxnRetryCounter()
-                                      << " for session " << _sessionId() << " already started",
-                        isInternalSessionForRetryableWrite(_sessionId()));
-                break;
-            }
-            case TransactionActions::kContinue: {
-                uassert(ErrorCodes::InvalidOptions,
-                        "Only the first command in a transaction may specify a readConcern",
-                        repl::ReadConcernArgs::get(opCtx).isEmpty());
-
-                APIParameters::get(opCtx) = o().apiParameters;
-                repl::ReadConcernArgs::get(opCtx) = o().readConcernArgs;
+            APIParameters::get(opCtx) = o().apiParameters;
+            repl::ReadConcernArgs::get(opCtx) = o().readConcernArgs;
 
-                ++p().latestStmtId;
-                _onContinue(opCtx);
-                break;
-            }
-            case TransactionActions::kCommit:
-                ++p().latestStmtId;
-                _onContinue(opCtx);
-                break;
-        }
-    } else {
-        uassert(ErrorCodes::IllegalOperation,
-                str::stream() << "Cannot " << actionTypeToString(action) << " transaction "
-                              << txnNumberAndRetryCounter.getTxnNumber() << " on session "
-                              << _sessionId() << " using txnRetryCounter "
-                              << txnNumberAndRetryCounter.getTxnRetryCounter()
-                              << " because it has already started to commit using "
-                              << "a lower txnRetryCounter "
-                              << o().txnNumberAndRetryCounter.getTxnRetryCounter(),
-                o().commitType == CommitType::kNotInitiated || !o().abortCause.empty());
-
-        if (action == TransactionActions::kCommit) {
-            // If the first action seen by the router for this txnRetryCounter is to commit, that
-            // means that the client is attempting to recover a commit decision.
-            _resetRouterState(opCtx, txnNumberAndRetryCounter);
-            p().isRecoveringCommit = true;
-            return;
+            ++p().latestStmtId;
+            _onContinue(opCtx);
+            break;
         }
-        uassert(ErrorCodes::IllegalOperation,
-                str::stream() << "Cannot " << actionTypeToString(action) << " transaction "
-                              << txnNumberAndRetryCounter.getTxnNumber() << " on session "
-                              << _sessionId() << " using txnRetryCounter "
-                              << txnNumberAndRetryCounter.getTxnRetryCounter()
-                              << " because it is using a lower txnRetryCounter "
-                              << o().txnNumberAndRetryCounter.getTxnRetryCounter(),
-                action == TransactionActions::kStart);
-        _resetRouterStateForStartTransaction(opCtx, txnNumberAndRetryCounter);
+        case TransactionActions::kCommit:
+            ++p().latestStmtId;
+            _onContinue(opCtx);
+            break;
     }
 }
 
-void TransactionRouter::Router::_beginNewTxnNumber(
-    OperationContext* opCtx,
-    TxnNumberAndRetryCounter txnNumberAndRetryCounter,
-    TransactionActions action) {
+void TransactionRouter::Router::_beginTxn(OperationContext* opCtx,
+                                          TxnNumberAndRetryCounter txnNumberAndRetryCounter,
+                                          TransactionActions action) {
     invariant(txnNumberAndRetryCounter.getTxnNumber() >
               o().txnNumberAndRetryCounter.getTxnNumber());
 
@@ -1046,12 +1003,10 @@ void TransactionRouter::Router::_beginNewTxnNumber(
     };
 }
 
-void TransactionRouter::Router::beginOrContinueTxn(
-    OperationContext* opCtx,
-    TxnNumberAndRetryCounter txnNumberAndRetryCounter,
-    TransactionActions action) {
-    invariant(txnNumberAndRetryCounter.getTxnRetryCounter() >= 0,
-              "Cannot specify a negative txnRetryCounter");
+void TransactionRouter::Router::beginOrContinueTxn(OperationContext* opCtx,
+                                                   TxnNumber txnNumber,
+                                                   TransactionActions action) {
+    const TxnNumberAndRetryCounter txnNumberAndRetryCounter{txnNumber, 0};
 
     if (txnNumberAndRetryCounter.getTxnNumber() < o().txnNumberAndRetryCounter.getTxnNumber()) {
         // This transaction is older than the transaction currently in progress, so throw an error.
@@ -1072,10 +1027,10 @@ void TransactionRouter::Router::beginOrContinueTxn(
                                                 o().apiParameters.toBSON().toString()),
                 apiParamsFromClient == o().apiParameters);
         }
-        _beginOrContinueActiveTxnNumber(opCtx, txnNumberAndRetryCounter, action);
+        _continueTxn(opCtx, txnNumberAndRetryCounter, action);
     } else {
         // This is a newer transaction.
-        _beginNewTxnNumber(opCtx, txnNumberAndRetryCounter, action);
+        _beginTxn(opCtx, txnNumberAndRetryCounter, action);
     }
 
     _updateLastClientInfo(opCtx->getClient());
diff --git a/src/mongo/s/transaction_router.h b/src/mongo/s/transaction_router.h
index 377ff75de85..b3021f0aaa9 100644
--- a/src/mongo/s/transaction_router.h
+++ b/src/mongo/s/transaction_router.h
@@ -368,7 +368,7 @@ public:
          * the previous transaction state.
          */
         void beginOrContinueTxn(OperationContext* opCtx,
-                                TxnNumberAndRetryCounter txnNumberAndRetryCounter,
+                                TxnNumber txnNumber,
                                 TransactionActions action);
 
         /**
@@ -559,17 +559,17 @@ public:
         /**
          * Continues or restarts the currently active transaction.
          */
-        void _beginOrContinueActiveTxnNumber(OperationContext* opCtx,
-                                             TxnNumberAndRetryCounter txnNumberAndRetryCounter,
-                                             TransactionActions action);
+        void _continueTxn(OperationContext* opCtx,
+                          TxnNumberAndRetryCounter txnNumberAndRetryCounter,
+                          TransactionActions action);
 
         /**
          * Starts a new transaction or continues a transaction started by a different router to
          * recover the commit decision.
          */
-        void _beginNewTxnNumber(OperationContext* opCtx,
-                                TxnNumberAndRetryCounter txnNumberAndRetryCounter,
-                                TransactionActions action);
+        void _beginTxn(OperationContext* opCtx,
+                       TxnNumberAndRetryCounter txnNumberAndRetryCounter,
+                       TransactionActions action);
 
         /**
          * Internal method for committing a transaction. Should only throw on failure to send
diff --git a/src/mongo/s/transaction_router_test.cpp b/src/mongo/s/transaction_router_test.cpp
index f0d0ab36264..dfcd95b305b 100644
--- a/src/mongo/s/transaction_router_test.cpp
+++ b/src/mongo/s/transaction_router_test.cpp
@@ -235,9 +235,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -274,9 +273,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, BasicStartTxnWithAtClusterTime)
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -314,9 +312,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotContiueTxnWithoutStarting)
 
     auto txnRouter = TransactionRouter::get(operationContext());
     ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue),
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue),
         AssertionException,
         ErrorCodes::NoSuchTransaction);
 }
@@ -325,9 +322,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, NewParticipantMustAttachTxnAndRe
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -392,9 +388,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, StartingNewTxnShouldClearState)
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     {
@@ -414,9 +409,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, StartingNewTxnShouldClearState)
     }
 
     TxnNumber txnNum2{5};
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum2, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum2, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -437,25 +431,13 @@ TEST_F(TransactionRouterTestWithDefaultSession, StartingNewTxnShouldClearState)
     }
 }
 
-DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
-             CannotSpecifyNegativeTxnRetryCounter,
-             "Cannot specify a negative txnRetryCounter") {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, -1),
-                                 TransactionRouter::TransactionActions::kStart);
-}
-
 TEST_F(TransactionRouterTestWithDefaultSession,
        DoNotAttachTxnRetryCounterIfTxnRetryCounterIsDefault) {
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
@@ -468,370 +450,12 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     ASSERT_EQ(newCmd.hasField("txnRetryCounter"), false);
 }
 
-TEST_F(TransactionRouterTestWithDefaultSession,
-       AttachTxnRetryCounterIfTxnRetryCounterIsNotDefault) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
-    txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
-
-    auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                    shard1,
-                                                    BSON("insert"
-                                                         << "test"
-                                                         << "txnNumber" << txnNum));
-    ASSERT_EQ(newCmd.hasField("txnRetryCounter"), true);
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession, NotAttachTxnRetryCounterIfFeatureFlagIsNotEnabled) {
-    RAIIServerParameterControllerForTest controller{"featureFlagInternalTransactions", false};
-
-    TxnNumber txnNum{3};
-    BSONObj expectedCmd = BSON("insert"
-                               << "test"
-                               << "readConcern"
-                               << BSON("level"
-                                       << "snapshot"
-                                       << "atClusterTime" << kInMemoryLogicalTime.asTimestamp())
-                               << "startTransaction" << true << "coordinator" << true
-                               << "autocommit" << false << "txnNumber" << txnNum);
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    ASSERT_BSONOBJ_EQ(expectedCmd,
-                      txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                        shard1,
-                                                        BSON("insert"
-                                                             << "test")));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanRestartInProgressTransactionUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-    BSONObj expectedCmd = BSON("insert"
-                               << "test"
-                               << "readConcern"
-                               << BSON("level"
-                                       << "snapshot"
-                                       << "atClusterTime" << kInMemoryLogicalTime.asTimestamp())
-                               << "startTransaction" << true << "coordinator" << true
-                               << "autocommit" << false << "txnNumber" << txnNum);
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    ASSERT_BSONOBJ_EQ(expectedCmd,
-                      txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                        shard1,
-                                                        BSON("insert"
-                                                             << "test")));
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    ASSERT_BSONOBJ_EQ(expectedCmd.addFields(BSON("txnRetryCounter" << 1)),
-                      txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                        shard1,
-                                                        BSON("insert"
-                                                             << "test")));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanRestartAbortedTransactionUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-    BSONObj expectedCmd = BSON("insert"
-                               << "test"
-                               << "readConcern"
-                               << BSON("level"
-                                       << "snapshot"
-                                       << "atClusterTime" << kInMemoryLogicalTime.asTimestamp())
-                               << "startTransaction" << true << "coordinator" << true
-                               << "autocommit" << false << "txnNumber" << txnNum);
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    ASSERT_BSONOBJ_EQ(expectedCmd,
-                      txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                        shard1,
-                                                        BSON("insert"
-                                                             << "test")));
-    txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
-    startCapturingLogMessages();
-    auto future = launchAsync([&] { txnRouter.abortTransaction(operationContext()); });
-    expectAbortTransactions({hostAndPort1}, *operationContext()->getLogicalSessionId(), txnNum);
-    future.default_timed_get();
-    stopCapturingLogMessages();
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    ASSERT_BSONOBJ_EQ(expectedCmd.addFields(BSON("txnRetryCounter" << 1)),
-                      txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                        shard1,
-                                                        BSON("insert"
-                                                             << "test")));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanRestartTransactionWithFailedCommitUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
-    txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
-    ASSERT(TransactionRouter::Participant::ReadOnly::kNotReadOnly ==
-           txnRouter.getParticipant(shard1)->readOnly);
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kCommit);
-    auto future =
-        launchAsync([&] { txnRouter.commitTransaction(operationContext(), boost::none); });
-    expectCommitTransaction(kDummyErrorRes);
-    future.default_timed_get();
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kCommit);
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CannotRestartCommittedTransactionUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kCommit);
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-
-    ASSERT_THROWS_CODE(txnRouter.beginOrContinueTxn(operationContext(),
-                                                    TxnNumberAndRetryCounter(txnNum, 1),
-                                                    TransactionRouter::TransactionActions::kStart),
-                       AssertionException,
-                       ErrorCodes::IllegalOperation);
-
-    commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CannotRestartTransactionUsingTxnRetryCounterLessThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-
-    ASSERT_THROWS_CODE(txnRouter.beginOrContinueTxn(operationContext(),
-                                                    TxnNumberAndRetryCounter(txnNum, 0),
-                                                    TransactionRouter::TransactionActions::kStart),
-                       AssertionException,
-                       ErrorCodes::TxnRetryCounterTooOld);
-    try {
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue);
-    } catch (const TxnRetryCounterTooOldException& ex) {
-        auto info = ex.extraInfo<TxnRetryCounterTooOldInfo>();
-        ASSERT_EQ(info->getTxnRetryCounter(), 1);
-    }
-
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanContinueTransactionUsingTxnRetryCounterEqualToLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kContinue);
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CannotContinueTransactionUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 1),
-                                     TransactionRouter::TransactionActions::kContinue),
-        AssertionException,
-        ErrorCodes::IllegalOperation);
-
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CannotContinueTransactionUsingTxnRetryCounterLessThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue),
-        AssertionException,
-        ErrorCodes::TxnRetryCounterTooOld);
-    try {
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue);
-    } catch (const TxnRetryCounterTooOldException& ex) {
-        auto info = ex.extraInfo<TxnRetryCounterTooOldInfo>();
-        ASSERT_EQ(info->getTxnRetryCounter(), 1);
-    }
-
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanCommitTransactionUsingTxnRetryCounterEqualToLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kCommit);
-
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CanCommitTransactionUsingTxnRetryCounterGreaterThanLastUsed) {
-    TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter0{0};
-    TxnRetryCounter txnRetryCounter1{1};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter0),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter1),
-                                 TransactionRouter::TransactionActions::kCommit);
-
-    TxnRecoveryToken recoveryToken;
-    recoveryToken.setRecoveryShardId(shard1);
-
-    auto future =
-        launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
-
-    onCommand([&](const RemoteCommandRequest& request) { return BSON("ok" << 1); });
-
-    future.default_timed_get();
-}
-
-TEST_F(TransactionRouterTestWithDefaultSession,
-       CannotCommitTransactionUsingTxnRetryCounterLessThanLastUsed) {
-    TxnNumber txnNum{3};
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 1),
-                                 TransactionRouter::TransactionActions::kStart);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    // (Must reset readConcern from "snapshot".)
-    repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    ASSERT_THROWS_CODE(txnRouter.beginOrContinueTxn(operationContext(),
-                                                    TxnNumberAndRetryCounter(txnNum, 0),
-                                                    TransactionRouter::TransactionActions::kCommit),
-                       AssertionException,
-                       ErrorCodes::TxnRetryCounterTooOld);
-    try {
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kCommit);
-    } catch (const TxnRetryCounterTooOldException& ex) {
-        auto info = ex.extraInfo<TxnRetryCounterTooOldInfo>();
-        ASSERT_EQ(info->getTxnRetryCounter(), 1);
-    }
-
-    auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
-    ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
-}
-
 TEST_F(TransactionRouterTestWithDefaultSession, FirstParticipantIsCoordinator) {
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT_FALSE(txnRouter.getCoordinatorId());
@@ -853,9 +477,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, FirstParticipantIsCoordinator) {
     }
 
     TxnNumber txnNum2{5};
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum2, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum2, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT_FALSE(txnRouter.getCoordinatorId());
@@ -873,9 +496,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardDoesNotGetSetForRea
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // The recovery shard is unset initially.
@@ -894,9 +516,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardDoesNotGetSetForRea
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyTrueResponse);
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     // The recovery shard is not set even if the participants say they did a write for commit.
     auto future =
@@ -917,9 +538,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -933,9 +553,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -955,9 +574,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says read-only.
@@ -977,9 +595,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
@@ -1002,9 +619,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
@@ -1015,9 +631,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 
     // New statement.
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // Shard2 responds, it doesn't matter whether it's read-only, just that it's a pending
     // participant.
@@ -1040,9 +655,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardIsResetOnStartingNe
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
@@ -1053,9 +667,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardIsResetOnStartingNe
 
     // Start new transaction on session.
     TxnNumber newTxnNum{4};
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(newTxnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), newTxnNum, TransactionRouter::TransactionActions::kStart);
 
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 }
@@ -1064,9 +677,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, DoesNotAttachTxnNumIfAlreadyTher
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -1092,9 +704,8 @@ DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(),
@@ -1108,9 +719,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, AttachTxnValidatesReadConcernIfA
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     {
@@ -1140,16 +750,14 @@ TEST_F(TransactionRouterTestWithDefaultSession, SameAPIParametersAfterFirstState
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Continuing with the same API params succeeds. (Must reset readConcern from "snapshot".)
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 }
 
 TEST_F(TransactionRouterTestWithDefaultSession, DifferentAPIParametersAfterFirstStatement) {
@@ -1159,18 +767,16 @@ TEST_F(TransactionRouterTestWithDefaultSession, DifferentAPIParametersAfterFirst
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Can't continue with different params. (Must reset readConcern from "snapshot".)
     APIParameters::get(operationContext()).setAPIStrict(true);
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
     ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue),
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue),
         DBException,
         ErrorCodes::APIMismatchError);
 }
@@ -1182,18 +788,16 @@ TEST_F(TransactionRouterTestWithDefaultSession, NoAPIParametersAfterFirstStateme
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Can't continue without params. (Must reset readConcern from "snapshot".)
     APIParameters::get(operationContext()) = APIParameters();
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
     ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue),
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue),
         DBException,
         ErrorCodes::APIMismatchError);
 }
@@ -1202,15 +806,13 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotSpecifyReadConcernAfterFir
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT_THROWS_CODE(
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, 0),
-                                     TransactionRouter::TransactionActions::kContinue),
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue),
         DBException,
         ErrorCodes::InvalidOptions);
 }
@@ -1221,9 +823,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, PassesThroughEmptyReadConcernToP
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -1248,9 +849,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedNewObj = BSON("insert"
@@ -1274,9 +874,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RejectUnsupportedReadConcernLeve
         TxnNumber txnNum{3};
         auto txnRouter = TransactionRouter::get(operationContext());
         ASSERT_THROWS_CODE(
-            txnRouter.beginOrContinueTxn(operationContext(),
-                                         TxnNumberAndRetryCounter(txnNum, 0),
-                                         TransactionRouter::TransactionActions::kStart),
+            txnRouter.beginOrContinueTxn(
+                operationContext(), txnNum, TransactionRouter::TransactionActions::kStart),
             DBException,
             ErrorCodes::InvalidOptions);
     }
@@ -1290,9 +889,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RejectUnsupportedLevelsWithAfter
         TxnNumber txnNum{3};
         auto txnRouter = TransactionRouter::get(operationContext());
         ASSERT_THROWS_CODE(
-            txnRouter.beginOrContinueTxn(operationContext(),
-                                         TxnNumberAndRetryCounter(txnNum, 0),
-                                         TransactionRouter::TransactionActions::kStart),
+            txnRouter.beginOrContinueTxn(
+                operationContext(), txnNum, TransactionRouter::TransactionActions::kStart),
             DBException,
             ErrorCodes::InvalidOptions);
     }
@@ -1306,9 +904,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, RejectUnsupportedLevelsWithAfter
         TxnNumber txnNum{3};
         auto txnRouter = TransactionRouter::get(operationContext());
         ASSERT_THROWS_CODE(
-            txnRouter.beginOrContinueTxn(operationContext(),
-                                         TxnNumberAndRetryCounter(txnNum, 0),
-                                         TransactionRouter::TransactionActions::kStart),
+            txnRouter.beginOrContinueTxn(
+                operationContext(), txnNum, TransactionRouter::TransactionActions::kStart),
             DBException,
             ErrorCodes::InvalidOptions);
     }
@@ -1318,9 +915,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotCommitWithoutParticipantsO
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT_THROWS(txnRouter.commitTransaction(operationContext(), boost::none), AssertionException);
@@ -1329,7 +925,6 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotCommitWithoutParticipantsO
 void checkSessionDetails(const BSONObj& cmdObj,
                          const LogicalSessionId& lsid,
                          const TxnNumber txnNum,
-                         const TxnRetryCounter txnRetryCounter,
                          boost::optional<bool> isCoordinator) {
     auto osi = OperationSessionInfoFromClient::parse("testTxnRouter"_sd, cmdObj);
 
@@ -1342,9 +937,7 @@ void checkSessionDetails(const BSONObj& cmdObj,
     ASSERT(osi.getAutocommit());
     ASSERT_FALSE(*osi.getAutocommit());
 
-    if (osi.getTxnRetryCounter()) {
-        ASSERT_EQ(txnRetryCounter, *osi.getTxnRetryCounter());
-    }
+    ASSERT_TRUE(cmdObj["txnRetryCounter"].eoo());
 
     if (isCoordinator) {
         ASSERT_EQ(*isCoordinator, cmdObj["coordinator"].trueValue());
@@ -1364,14 +957,12 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     auto commitResult = txnRouter.commitTransaction(operationContext(), boost::none);
     ASSERT_BSONOBJ_EQ(commitResult, BSON("ok" << 1));
@@ -1385,12 +976,10 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        SendCommitDirectlyForSingleParticipantThatIsReadOnly) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1399,9 +988,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     auto future =
         launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
@@ -1413,8 +1001,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
         ASSERT_EQ(cmdName, "commitTransaction");
 
-        checkSessionDetails(
-            request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
         return BSON("ok" << 1);
     });
@@ -1425,12 +1012,10 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        SendCommitDirectlyForSingleParticipantThatDidAWrite) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1439,9 +1024,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     auto future =
         launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
@@ -1453,8 +1037,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
         ASSERT_EQ(cmdName, "commitTransaction");
 
-        checkSessionDetails(
-            request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
         return BSON("ok" << 1);
     });
@@ -1465,12 +1048,10 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        SendCommitDirectlyForMultipleParticipantsThatAreAllReadOnly) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1481,9 +1062,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     auto future =
         launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
@@ -1503,11 +1083,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             ASSERT_EQ(cmdName, "commitTransaction");
 
             // The shard with hostAndPort1 is expected to be the coordinator.
-            checkSessionDetails(request.cmdObj,
-                                getSessionId(),
-                                txnNum,
-                                txnRetryCounter,
-                                (request.target == hostAndPort1));
+            checkSessionDetails(
+                request.cmdObj, getSessionId(), txnNum, (request.target == hostAndPort1));
 
             return kOkReadOnlyTrueResponse;
         });
@@ -1521,12 +1098,10 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        SendCoordinateCommitForMultipleParticipantsOnlyOneDidAWrite) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1534,9 +1109,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
@@ -1561,8 +1135,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             expectedParticipants.erase(shardId);
         }
 
-        checkSessionDetails(
-            request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
         return BSON("ok" << 1);
     });
@@ -1573,12 +1146,10 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        SendCoordinateCommitForMultipleParticipantsMoreThanOneDidAWrite) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1586,9 +1157,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
@@ -1613,8 +1183,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             expectedParticipants.erase(shardId);
         }
 
-        checkSessionDetails(
-            request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
         return BSON("ok" << 1);
     });
@@ -1625,7 +1194,6 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -1637,9 +1205,7 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
 
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(shard1);
@@ -1657,8 +1223,7 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
         auto participantElements = request.cmdObj["participants"].Array();
         ASSERT_TRUE(participantElements.empty());
 
-        checkSessionDetails(
-            request.cmdObj, lsid, txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, lsid, txnNum, true /* isCoordinator */);
         checkWriteConcern(request.cmdObj, writeConcern);
 
         return BSON("ok" << 1);
@@ -1669,9 +1234,8 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
     // Sending commit with a recovery token again should cause the router to use the recovery path
     // again.
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
     future = launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
 
@@ -1685,8 +1249,7 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
         auto participantElements = request.cmdObj["participants"].Array();
         ASSERT_TRUE(participantElements.empty());
 
-        checkSessionDetails(
-            request.cmdObj, lsid, txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, lsid, txnNum, true /* isCoordinator */);
         checkWriteConcern(request.cmdObj, writeConcern);
 
         return BSON("ok" << 1);
@@ -1698,7 +1261,6 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithNoParticipants) {
 TEST_F(TransactionRouterTestWithDefaultSession,
        CrossShardTxnCommitWorksAfterRecoveryCommitForPreviousTransaction) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setTxnNumber(txnNum);
@@ -1710,9 +1272,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto txnRouter = TransactionRouter::get(opCtx);
     // Simulate recovering a commit with a recovery token and no participants.
     {
-        txnRouter.beginOrContinueTxn(opCtx,
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kCommit);
+        txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
         TxnRecoveryToken recoveryToken;
         recoveryToken.setRecoveryShardId(shard1);
@@ -1730,8 +1290,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             auto participantElements = request.cmdObj["participants"].Array();
             ASSERT_TRUE(participantElements.empty());
 
-            checkSessionDetails(
-                request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+            checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
             checkWriteConcern(request.cmdObj, writeConcern);
 
             return BSON("ok" << 1);
@@ -1744,9 +1303,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // should be sent with the correct participant list.
     {
         ++txnNum;
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
         txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1754,9 +1312,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
         txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kCommit);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
         TxnRecoveryToken recoveryToken;
         recoveryToken.setRecoveryShardId(shard1);
@@ -1781,8 +1338,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
                 expectedParticipants.erase(shardId);
             }
 
-            checkSessionDetails(
-                request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+            checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
             return BSON("ok" << 1);
         });
@@ -1794,7 +1350,6 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 TEST_F(TransactionRouterTestWithDefaultSession,
        RouterShouldWorkAsRecoveryRouterEvenIfItHasSeenPreviousTransactions) {
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setTxnNumber(txnNum);
@@ -1807,9 +1362,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // Run a cross-shard transaction with two-phase commit. The commit should be sent with the
     // correct participant list.
     {
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
         txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -1817,9 +1371,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
         txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kCommit);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
 
         TxnRecoveryToken recoveryToken;
         recoveryToken.setRecoveryShardId(shard1);
@@ -1844,8 +1397,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
                 expectedParticipants.erase(shardId);
             }
 
-            checkSessionDetails(
-                request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+            checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
 
             return BSON("ok" << 1);
         });
@@ -1858,9 +1410,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     {
         ++txnNum;
 
-        txnRouter.beginOrContinueTxn(opCtx,
-                                     TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                     TransactionRouter::TransactionActions::kCommit);
+        txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
         TxnRecoveryToken recoveryToken;
         recoveryToken.setRecoveryShardId(shard1);
@@ -1878,8 +1428,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             auto participantElements = request.cmdObj["participants"].Array();
             ASSERT_TRUE(participantElements.empty());
 
-            checkSessionDetails(
-                request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
+            checkSessionDetails(request.cmdObj, getSessionId(), txnNum, true /* isCoordinator */);
             checkWriteConcern(request.cmdObj, writeConcern);
 
             return BSON("ok" << 1);
@@ -1903,8 +1452,7 @@ TEST_F(TransactionRouterTest, CommitWithEmptyRecoveryToken) {
 
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
     TxnRecoveryToken recoveryToken;
     ASSERT_THROWS_CODE(txnRouter.commitTransaction(operationContext(), recoveryToken),
@@ -1926,8 +1474,7 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithUnknownShard) {
 
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
     TxnRecoveryToken recoveryToken;
     recoveryToken.setRecoveryShardId(ShardId("magicShard"));
@@ -1945,55 +1492,12 @@ TEST_F(TransactionRouterTest, CommitWithRecoveryTokenWithUnknownShard) {
     ASSERT_THROWS_CODE(future.default_timed_get(), DBException, ErrorCodes::ShardNotFound);
 }
 
-TEST_F(TransactionRouterTestWithDefaultSession, CommitWithRecoveryTokenAndTxnRetryCounter) {
-    TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{1};
-
-    operationContext()->setTxnNumber(txnNum);
-
-    WriteConcernOptions writeConcern(
-        10, WriteConcernOptions::SyncMode::NONE, WriteConcernOptions::kNoTimeout);
-    operationContext()->setWriteConcern(writeConcern);
-
-    auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kCommit);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    TxnRecoveryToken recoveryToken;
-    recoveryToken.setRecoveryShardId(shard1);
-
-    auto future =
-        launchAsync([&] { txnRouter.commitTransaction(operationContext(), recoveryToken); });
-
-    onCommand([&](const RemoteCommandRequest& request) {
-        ASSERT_EQ(hostAndPort1, request.target);
-        ASSERT_EQ("admin", request.dbname);
-
-        auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
-        ASSERT_EQ(cmdName, "coordinateCommitTransaction");
-
-        auto participantElements = request.cmdObj["participants"].Array();
-        ASSERT_TRUE(participantElements.empty());
-
-        checkSessionDetails(
-            request.cmdObj, getSessionId(), txnNum, txnRetryCounter, true /* isCoordinator */);
-        checkWriteConcern(request.cmdObj, writeConcern);
-
-        return BSON("ok" << 1);
-    });
-
-    future.default_timed_get();
-}
-
 TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsResetAtClusterTime) {
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedReadConcern = BSON("level"
@@ -2040,9 +1544,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     BSONObj expectedReadConcern = BSON("level"
@@ -2080,9 +1583,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // Later statements cannot change atClusterTime.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     LogicalTime laterTimeNewStmt(Timestamp(1000, 1));
     ASSERT_GT(laterTimeNewStmt, laterTimeSameStmt);
@@ -2103,9 +1605,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsClearsAllParticipa
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Successfully start a transaction on two shards, selecting one as the coordinator.
@@ -2154,9 +1655,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotContinueOnSnapshotErrorAft
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT(txnRouter.canContinueOnSnapshotError());
@@ -2164,24 +1664,21 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotContinueOnSnapshotErrorAft
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
     ASSERT_FALSE(txnRouter.canContinueOnSnapshotError());
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
     ASSERT_FALSE(txnRouter.canContinueOnSnapshotError());
 }
 
 TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreatedAt) {
     TxnNumber txnNum{3};
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Transaction 1 contacts shard1 and shard2 during the first command, then shard3 in the second
@@ -2195,9 +1692,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
     ASSERT_EQ(txnRouter.getParticipant(shard2)->stmtIdCreatedAt, initialStmtId);
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     ShardId shard3("shard3");
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
@@ -2212,9 +1708,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
     repl::ReadConcernArgs::get(operationContext()) =
         repl::ReadConcernArgs(repl::ReadConcernLevel::kSnapshotReadConcern);
     TxnNumber txnNum2{5};
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum2, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum2, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
@@ -2224,9 +1719,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
     ASSERT_EQ(txnRouter.getParticipant(shard2)->stmtIdCreatedAt, initialStmtId);
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum2, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum2, TransactionRouter::TransactionActions::kContinue);
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_EQ(txnRouter.getParticipant(shard1)->stmtIdCreatedAt, initialStmtId + 1);
@@ -2237,9 +1731,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Start a transaction on two shards, selecting one as the coordinator, but simulate a
@@ -2283,9 +1776,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnlyNewlyCreatedParticipantsClea
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // First statement successfully targets one shard, selecing it as the coordinator.
@@ -2299,9 +1791,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnlyNewlyCreatedParticipantsClea
     // least one of them.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
@@ -2329,9 +1820,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
 
     // First statement selects an atClusterTime.
 
@@ -2341,9 +1831,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // change the atClusterTime.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     LogicalTime laterTime(Timestamp(1000, 1));
     ASSERT_GT(laterTime, kInMemoryLogicalTime);
@@ -2384,9 +1873,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, WritesCanOnlyBeRetriedIfFirstOve
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     for (auto writeCmd : writeCmds) {
@@ -2400,9 +1888,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, WritesCanOnlyBeRetriedIfFirstOve
     // Advance to the next command.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     for (auto writeCmd : writeCmds) {
         ASSERT_FALSE(txnRouter.canContinueOnStaleShardOrDbError(writeCmd, kDummyStatus));
@@ -2423,8 +1910,7 @@ TEST_F(TransactionRouterTest, AbortThrowsIfNoParticipants) {
 
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     ASSERT_THROWS_CODE(
@@ -2434,7 +1920,6 @@ TEST_F(TransactionRouterTest, AbortThrowsIfNoParticipants) {
 TEST_F(TransactionRouterTest, AbortForSingleParticipant) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2443,9 +1928,7 @@ TEST_F(TransactionRouterTest, AbortForSingleParticipant) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
@@ -2458,8 +1941,7 @@ TEST_F(TransactionRouterTest, AbortForSingleParticipant) {
         auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
         ASSERT_EQ(cmdName, "abortTransaction");
 
-        checkSessionDetails(
-            request.cmdObj, lsid, txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, lsid, txnNum, true /* isCoordinator */);
 
         return kOkReadOnlyFalseResponse;
     });
@@ -2471,7 +1953,6 @@ TEST_F(TransactionRouterTest, AbortForSingleParticipant) {
 TEST_F(TransactionRouterTest, AbortForMultipleParticipantsAllReturnSuccess) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2480,9 +1961,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsAllReturnSuccess) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
@@ -2503,7 +1982,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsAllReturnSuccess) {
             auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
             ASSERT_EQ(cmdName, "abortTransaction");
 
-            checkSessionDetails(request.cmdObj, lsid, txnNum, txnRetryCounter, target->second);
+            checkSessionDetails(request.cmdObj, lsid, txnNum, target->second);
 
             targets.erase(request.target);
             return kOkReadOnlyFalseResponse;
@@ -2517,7 +1996,6 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsAllReturnSuccess) {
 TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNoSuchTransaction) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2526,9 +2004,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNoSuchTransa
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
@@ -2552,7 +2028,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNoSuchTransa
             auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
             ASSERT_EQ(cmdName, "abortTransaction");
 
-            checkSessionDetails(request.cmdObj, lsid, txnNum, txnRetryCounter, target->second);
+            checkSessionDetails(request.cmdObj, lsid, txnNum, target->second);
 
             targets.erase(request.target);
 
@@ -2569,7 +2045,6 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNoSuchTransa
 TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNetworkError) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2578,9 +2053,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNetworkError
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
@@ -2604,7 +2077,7 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNetworkError
             auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
             ASSERT_EQ(cmdName, "abortTransaction");
 
-            checkSessionDetails(request.cmdObj, lsid, txnNum, txnRetryCounter, target->second);
+            checkSessionDetails(request.cmdObj, lsid, txnNum, target->second);
 
             targets.erase(request.target);
 
@@ -2626,9 +2099,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // One shard is targeted by the first statement.
@@ -2656,9 +2128,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     // Advance to a later client statement that targets a new shard.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     auto secondShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     ASSERT_TRUE(secondShardCmd["startTransaction"].trueValue());
@@ -2686,8 +2157,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortIsNoopWithNoParticipants) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Should not throw.
@@ -2697,7 +2167,6 @@ TEST_F(TransactionRouterTest, ImplicitAbortIsNoopWithNoParticipants) {
 TEST_F(TransactionRouterTest, ImplicitAbortForSingleParticipant) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2706,9 +2175,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortForSingleParticipant) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
@@ -2722,8 +2189,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortForSingleParticipant) {
         auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
         ASSERT_EQ(cmdName, "abortTransaction");
 
-        checkSessionDetails(
-            request.cmdObj, lsid, txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, lsid, txnNum, true /* isCoordinator */);
 
         return kOkReadOnlyFalseResponse;
     });
@@ -2734,7 +2200,6 @@ TEST_F(TransactionRouterTest, ImplicitAbortForSingleParticipant) {
 TEST_F(TransactionRouterTest, ImplicitAbortForMultipleParticipants) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2743,9 +2208,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortForMultipleParticipants) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
@@ -2765,7 +2228,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortForMultipleParticipants) {
             auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
             ASSERT_EQ(cmdName, "abortTransaction");
 
-            checkSessionDetails(request.cmdObj, lsid, txnNum, txnRetryCounter, target->second);
+            checkSessionDetails(request.cmdObj, lsid, txnNum, target->second);
 
             targets.erase(request.target);
             return kOkReadOnlyFalseResponse;
@@ -2778,7 +2241,6 @@ TEST_F(TransactionRouterTest, ImplicitAbortForMultipleParticipants) {
 TEST_F(TransactionRouterTest, ImplicitAbortIgnoresErrors) {
     LogicalSessionId lsid(makeLogicalSessionIdForTest());
     TxnNumber txnNum{3};
-    TxnRetryCounter txnRetryCounter{0};
 
     auto opCtx = operationContext();
     opCtx->setLogicalSessionId(lsid);
@@ -2787,9 +2249,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortIgnoresErrors) {
     RouterOperationContextSession scopedSession(opCtx);
     auto txnRouter = TransactionRouter::get(opCtx);
 
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, txnRetryCounter),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
@@ -2803,8 +2263,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortIgnoresErrors) {
         auto cmdName = request.cmdObj.firstElement().fieldNameStringData();
         ASSERT_EQ(cmdName, "abortTransaction");
 
-        checkSessionDetails(
-            request.cmdObj, lsid, txnNum, txnRetryCounter, true /* isCoordinator */);
+        checkSessionDetails(request.cmdObj, lsid, txnNum, true /* isCoordinator */);
 
         return BSON("ok" << 0);
     });
@@ -2822,8 +2281,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, AbortPropagatesWriteConcern) {
         10, WriteConcernOptions::SyncMode::NONE, WriteConcernOptions::kNoTimeout);
     opCtx->setWriteConcern(writeConcern);
 
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
     txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
@@ -2846,9 +2304,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinueOnlyOnStaleVersionOnFirs
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
@@ -2886,9 +2343,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinueOnlyOnStaleVersionOnFirs
 
     // Start a new transaction statement.
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // Cannot retry on a stale config error with one participant after the first statement.
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -2900,15 +2356,13 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinuingTransactionPlacesItsRe
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     ASSERT(repl::ReadConcernArgs::get(operationContext()).getLevel() ==
            repl::ReadConcernLevel::kSnapshotReadConcern);
@@ -2919,16 +2373,14 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
 
     // First statement does not select an atClusterTime, but does not target any participants.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // Subsequent statement does select an atClusterTime and does target a participant.
     txnRouter.setDefaultAtClusterTime(operationContext());
@@ -2946,9 +2398,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // The next statement cannot change the atClusterTime.
 
     repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     LogicalTime laterTimeSameStmt(Timestamp(100, 1));
     ASSERT_GT(laterTimeSameStmt, kInMemoryLogicalTime);
@@ -2969,9 +2420,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, NonSnapshotReadConcernHasNoAtClu
         repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs(rcIt.second);
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum++, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum++, TransactionRouter::TransactionActions::kStart);
 
         // No atClusterTime is placed on the router by default.
         ASSERT_FALSE(txnRouter.mustUseAtClusterTime());
@@ -2992,9 +2442,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs(rcIt.second);
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum++, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum++, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
         const BSONObj expectedRC = BSON("level" << rcIt.first);
@@ -3020,7 +2469,6 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     }
 }
 
-
 TEST_F(TransactionRouterTestWithDefaultSession,
        NonSnapshotReadConcernLevelsPreserveAfterClusterTime) {
     const auto clusterTime = LogicalTime(Timestamp(10, 1));
@@ -3030,9 +2478,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             repl::ReadConcernArgs(clusterTime, rcIt.second);
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum++, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum++, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
@@ -3052,9 +2499,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, NonSnapshotReadConcernLevelsPres
         repl::ReadConcernArgs::get(operationContext()) = repl::ReadConcernArgs(opTime, rcIt.second);
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(txnNum++, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), txnNum++, TransactionRouter::TransactionActions::kStart);
 
         // Call setDefaultAtClusterTime to simulate real command execution.
         txnRouter.setDefaultAtClusterTime(operationContext());
@@ -3073,9 +2519,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
 
     //
     // NoSuchTransaction is ignored when it is the top-level error code.
@@ -3104,9 +2549,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
 
     //
     // Retryable top-level error.
@@ -3137,9 +2581,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
 
     //
     // Non-retryable top-level error.
@@ -3170,9 +2613,8 @@ DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Add some participants to the list.
@@ -3188,9 +2630,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3204,9 +2645,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3230,9 +2670,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3256,9 +2695,8 @@ TEST_F(
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3283,9 +2721,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3309,9 +2746,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     TxnNumber txnNum{3};
 
     auto txnRouter = TransactionRouter::get(operationContext());
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -3328,9 +2764,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     repl::ReadConcernArgs secondRequestEmptyReadConcern;
     repl::ReadConcernArgs::get(operationContext()) = secondRequestEmptyReadConcern;
 
-    txnRouter.beginOrContinueTxn(operationContext(),
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(
+        operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // The router should throw regardless of whether the response says readOnly true or false.
     ASSERT_THROWS_CODE(
@@ -3349,17 +2784,14 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto opCtx = operationContext();
 
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
     txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
 
     // Continue causes the _latestStmtId to be bumped.
     repl::ReadConcernArgs::get(opCtx) = repl::ReadConcernArgs();
-    txnRouter.beginOrContinueTxn(opCtx,
-                                 TxnNumberAndRetryCounter(txnNum, 0),
-                                 TransactionRouter::TransactionActions::kContinue);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // Aborting will set the termination initiation state.
     auto future = launchAsync([&] { txnRouter.abortTransaction(opCtx); });
@@ -3378,8 +2810,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto opCtx = operationContext();
 
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
     txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
@@ -3401,8 +2832,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto opCtx = operationContext();
 
     auto txnRouter = TransactionRouter::get(opCtx);
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
     txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
@@ -3413,8 +2843,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
            txnRouter.getParticipant(shard1)->readOnly);
 
     // Commit causes the _latestStmtId to be bumped.
-    txnRouter.beginOrContinueTxn(
-        opCtx, TxnNumberAndRetryCounter(txnNum, 0), TransactionRouter::TransactionActions::kCommit);
+    txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kCommit);
 
     // Committing will set the termination initiation state.
     auto future = launchAsync([&] { txnRouter.commitTransaction(opCtx, boost::none); });
@@ -3439,9 +2868,8 @@ protected:
         TransactionRouterTestWithDefaultSession::setUp();
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
     }
 };
@@ -3512,31 +2940,27 @@ protected:
     }
 
     void beginTxnWithDefaultTxnNumber() {
-        txnRouter().beginOrContinueTxn(operationContext(),
-                                       TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                       TransactionRouter::TransactionActions::kStart);
+        txnRouter().beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter().setDefaultAtClusterTime(operationContext());
     }
 
     void beginSlowTxnWithDefaultTxnNumber() {
-        txnRouter().beginOrContinueTxn(operationContext(),
-                                       TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                       TransactionRouter::TransactionActions::kStart);
+        txnRouter().beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter().setDefaultAtClusterTime(operationContext());
         tickSource()->advance(Milliseconds(serverGlobalParams.slowMS + 1));
     }
 
     void beginRecoverCommitWithDefaultTxnNumber() {
-        txnRouter().beginOrContinueTxn(operationContext(),
-                                       TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                       TransactionRouter::TransactionActions::kCommit);
+        txnRouter().beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
         txnRouter().setDefaultAtClusterTime(operationContext());
     }
 
     void beginSlowRecoverCommitWithDefaultTxnNumber() {
-        txnRouter().beginOrContinueTxn(operationContext(),
-                                       TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                       TransactionRouter::TransactionActions::kCommit);
+        txnRouter().beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
         txnRouter().setDefaultAtClusterTime(operationContext());
         tickSource()->advance(Milliseconds(serverGlobalParams.slowMS + 1));
     }
@@ -3711,9 +3135,8 @@ protected:
     }
 
     void runRecoverWithTokenCommit(boost::optional<ShardId> recoveryShard) {
-        txnRouter().beginOrContinueTxn(operationContext(),
-                                       TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                       TransactionRouter::TransactionActions::kCommit);
+        txnRouter().beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
 
         TxnRecoveryToken recoveryToken;
         recoveryToken.setRecoveryShardId(recoveryShard);
@@ -3955,9 +3378,8 @@ TEST_F(TransactionRouterMetricsTest, SlowLoggingPrintsTimeActiveAndInactive) {
     tickSource()->advance(Microseconds(222222));
     assertTimeInactiveIs(Microseconds(222222));
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyOkRes);
 
     ASSERT_EQUALS(
@@ -4395,9 +3817,8 @@ TEST_F(TransactionRouterMetricsTest, DurationResetByNewTransaction) {
     txnRouter().commitTransaction(operationContext(), kDummyRecoveryToken);
 
     // Start a new transaction and verify the duration was reset.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
 
     assertDurationIs(Microseconds(0));
     tickSource()->advance(Microseconds(50));
@@ -4475,9 +3896,8 @@ TEST_F(TransactionRouterMetricsTest, CommitDurationResetByNewTransaction) {
     future.default_timed_get();
 
     // Start a new transaction and verify the commit duration was reset.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
 
     future = beginAndPauseCommit();
 
@@ -4608,9 +4028,8 @@ TEST_F(TransactionRouterMetricsTest, TimeActiveAndInactiveAdvanceSeparatelyAndSu
 
     // Will not advance after commit.
     // Neither can advance after a successful commit.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyOkRes);
 
     tickSource()->advance(Microseconds(150));
@@ -4677,9 +4096,8 @@ TEST_F(TransactionRouterMetricsTest, DurationsForImplicitlyAbortedActiveTxn) {
     assertTimeInactiveIs(kDefaultTimeInactive);
     assertDurationIs(kDefaultTimeActive + kDefaultTimeInactive);
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
     tickSource()->advance(Microseconds(100));
 
     assertTimeActiveIs(kDefaultTimeActive + Microseconds(100));
@@ -4702,9 +4120,8 @@ TEST_F(TransactionRouterMetricsTest, DurationsForImplicitlyAbortedEndedTxn) {
     assertTimeInactiveIs(kDefaultTimeInactive);
     assertDurationIs(kDefaultTimeActive + kDefaultTimeInactive);
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyOkRes);
     txnRouter().stash(operationContext());
 
@@ -4726,9 +4143,8 @@ TEST_F(TransactionRouterMetricsTest, NeitherTimeActiveNorInactiveAdvanceAfterSuc
 
     setUpDefaultTimeActiveAndInactive();
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyOkRes);
 
     // Neither can advance.
@@ -4741,9 +4157,8 @@ TEST_F(TransactionRouterMetricsTest, NeitherTimeActiveNorInactiveAdvanceAfterFai
 
     setUpDefaultTimeActiveAndInactive();
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
     runCommit(kDummyErrorRes);
 
     // Neither can advance.
@@ -4756,9 +4171,8 @@ TEST_F(TransactionRouterMetricsTest, TimeActiveAndInactiveAdvanceAfterUnknownCom
 
     setUpDefaultTimeActiveAndInactive();
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(Status(ErrorCodes::HostUnreachable, "dummy"), true /* expectRetries */);
 
     // timeActive can advance.
@@ -4772,9 +4186,8 @@ TEST_F(TransactionRouterMetricsTest, TimeActiveAndInactiveAdvanceAfterUnknownCom
     assertTimeActiveIs(kDefaultTimeActive + Microseconds(100));
     assertTimeInactiveIs(kDefaultTimeInactive + Microseconds(100));
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyRetryableErrorRes, true /* expectRetries */);
 
     // timeActive can advance.
@@ -4788,9 +4201,8 @@ TEST_F(TransactionRouterMetricsTest, TimeActiveAndInactiveAdvanceAfterUnknownCom
     assertTimeActiveIs(kDefaultTimeActive + Microseconds(200));
     assertTimeInactiveIs(kDefaultTimeInactive + Microseconds(200));
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kCommit);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kCommit);
     runCommit(kDummyOkRes);
 
     // The result is known, so neither can advance.
@@ -4804,9 +4216,8 @@ TEST_F(TransactionRouterMetricsTest, NeitherTimeActiveNorInactiveAdvanceAfterAbo
 
     setUpDefaultTimeActiveAndInactive();
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
     ASSERT_THROWS_CODE(txnRouter().abortTransaction(operationContext()),
                        AssertionException,
                        ErrorCodes::NoSuchTransaction);
@@ -4821,9 +4232,8 @@ TEST_F(TransactionRouterMetricsTest, NeitherTimeActiveNorInactiveAdvanceAfterImp
 
     setUpDefaultTimeActiveAndInactive();
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
     txnRouter().implicitlyAbortTransaction(operationContext(), kDummyStatus);
 
     // Neither can advance.
@@ -4862,9 +4272,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_Stash) {
 TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_BeginAfterStash) {
     beginRecoverCommitWithDefaultTxnNumber();
     txnRouter().stash(operationContext());
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
 
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentOpen());
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentActive());
@@ -4878,25 +4287,22 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_AreNotCumulative) {
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentActive());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentInactive());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentOpen());
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentActive());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentInactive());
 
     // Test inactive.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 2, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 2, TransactionRouter::TransactionActions::kStart);
     txnRouter().stash(operationContext());
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentOpen());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentActive());
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentInactive());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 3, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 3, TransactionRouter::TransactionActions::kStart);
     txnRouter().stash(operationContext());
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentOpen());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentActive());
@@ -4953,9 +4359,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_BeginAndStashForEndedT
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentActive());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentInactive());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
 
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentOpen());
     ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentActive());
@@ -5028,9 +4433,8 @@ TEST_F(TransactionRouterTest, RouterMetricsCurrent_ReapForInactiveTxn) {
 
         // Start a transaction on the session.
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(5, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), TxnNumber(5), TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
         ASSERT_EQUALS(1L, routerTxnMetrics->getCurrentOpen());
@@ -5133,9 +4537,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalStarted_IsCumulative) {
     beginTxnWithDefaultTxnNumber();
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalStarted());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalStarted());
 
     // Shouldn't go down when a transaction ends.
@@ -5186,9 +4589,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalCommitted_NotIncreasedByI
 TEST_F(TransactionRouterMetricsTest,
        RouterMetricsTotalCommitted_NotIncreasedByAbandonedTransaction) {
     beginTxnWithDefaultTxnNumber();
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalCommitted());
 }
 
@@ -5203,9 +4605,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalCommitted_IsCumulative) {
     runCommit(kDummyOkRes);
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalCommitted());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     runCommit(kDummyOkRes);
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalCommitted());
 }
@@ -5232,9 +4633,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalAborted_NotIncreasedByUnk
 
 TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalAborted_NotIncreasedByAbandonedTransaction) {
     beginTxnWithDefaultTxnNumber();
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalAborted());
 }
 
@@ -5271,9 +4671,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalAborted_IsCumulative) {
                        ErrorCodes::NoSuchTransaction);
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalAborted());
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_THROWS_CODE(txnRouter().abortTransaction(operationContext()),
                        AssertionException,
                        ErrorCodes::NoSuchTransaction);
@@ -5299,9 +4698,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalContactedParticipants) {
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalContactedParticipants());
 
     // Is cumulative across transactions.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalContactedParticipants());
 
     txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
@@ -5383,9 +4781,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalParticipantsAtCommit) {
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalParticipantsAtCommit());
 
     // Is cumulative across transactions.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     runCommit(kDummyOkRes);
     ASSERT_EQUALS(3L, routerTxnMetrics()->getTotalParticipantsAtCommit());
@@ -5466,9 +4863,8 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCommitTypeStatsSuccessfulDurat
                       .successfulDurationMicros.load());
 
     // Start a new transaction and verify that successful commit duration is cumulative.
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber + 1, 0),
-                                   TransactionRouter::TransactionActions::kStart);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     txnRouter().setDefaultAtClusterTime(operationContext());
     future = beginAndPauseCommit();
     tickSource()->advance(Microseconds(100));
@@ -5534,7 +4930,6 @@ TEST_F(TransactionRouterMetricsTest, ReportResources) {
     ASSERT_EQ(transactionDocument.getField("numNonReadOnlyParticipants").numberInt(), 0);
     ASSERT_EQ(transactionDocument.getField("numReadOnlyParticipants").numberInt(), 0);
 
-
     ASSERT_EQ(state.getField("host").valueStringData().toString(), getHostNameCachedAndPort());
     ASSERT_EQ(state.getField("desc").valueStringData().toString(), "inactive transaction");
     ASSERT_BSONOBJ_EQ(state.getField("lsid").Obj(), getSessionId().toBSON());
@@ -5583,9 +4978,8 @@ TEST_F(TransactionRouterMetricsTest, ReportResourcesWithParticipantList) {
     txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter().processParticipantResponse(operationContext(), shard2, kOkReadOnlyTrueResponse);
 
-    txnRouter().beginOrContinueTxn(operationContext(),
-                                   TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                   TransactionRouter::TransactionActions::kContinue);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
 
     // Verify participants array has been updated with proper ReadOnly responses.
 
diff --git a/src/mongo/s/write_ops/batch_write_exec_test.cpp b/src/mongo/s/write_ops/batch_write_exec_test.cpp
index 7b29c17b72e..0bbb85f6ff7 100644
--- a/src/mongo/s/write_ops/batch_write_exec_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_exec_test.cpp
@@ -2056,9 +2056,8 @@ public:
         _scopedSession.emplace(operationContext());
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
     }
 
@@ -2203,9 +2202,8 @@ public:
         _scopedSession.emplace(operationContext());
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
     }
 
@@ -2331,9 +2329,8 @@ public:
         _scopedSession.emplace(operationContext());
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
     }
 
diff --git a/src/mongo/s/write_ops/batch_write_op_test.cpp b/src/mongo/s/write_ops/batch_write_op_test.cpp
index 2d0012cbabb..146f36fb458 100644
--- a/src/mongo/s/write_ops/batch_write_op_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_op_test.cpp
@@ -1614,9 +1614,8 @@ public:
         _scopedSession.emplace(operationContext());
 
         auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(operationContext(),
-                                     TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                     TransactionRouter::TransactionActions::kStart);
+        txnRouter.beginOrContinueTxn(
+            operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kStart);
     }
 
     void tearDown() override {
diff --git a/src/mongo/s/write_ops/write_op_test.cpp b/src/mongo/s/write_ops/write_op_test.cpp
index 5444a801548..da7ced08dde 100644
--- a/src/mongo/s/write_ops/write_op_test.cpp
+++ b/src/mongo/s/write_ops/write_op_test.cpp
@@ -411,9 +411,7 @@ TEST_F(WriteOpTransactionTest, TargetMultiAllShardsAndErrorSingleChildOp) {
     _opCtx->setTxnNumber(kTxnNumber);
 
     auto txnRouter = TransactionRouter::get(_opCtx);
-    txnRouter.beginOrContinueTxn(_opCtx,
-                                 TxnNumberAndRetryCounter(kTxnNumber, 0),
-                                 TransactionRouter::TransactionActions::kStart);
+    txnRouter.beginOrContinueTxn(_opCtx, kTxnNumber, TransactionRouter::TransactionActions::kStart);
 
     // Do multi-target write op
     WriteOp writeOp(BatchItemRef(&request, 0), true);