Update upstream source from tag 'upstream/6.0.0'master

Update to upstream version '6.0.0'
with Debian dir 5604a80ec1c96ca76f25f40d78e6ef855abec322

144 files changed, 2063 insertions, 6042 deletions

diff --git a/src/mongo/s/SConscript b/src/mongo/s/SConscript
index e24b7998cb4..336e7a2ff98 100644
--- a/src/mongo/s/SConscript
+++ b/src/mongo/s/SConscript
@@ -37,7 +37,6 @@ env.Library(
         '$BUILD_DIR/mongo/db/fle_crud',
         '$BUILD_DIR/mongo/db/not_primary_error_tracker',
         '$BUILD_DIR/mongo/db/timeseries/timeseries_conversion_util',
-        '$BUILD_DIR/mongo/db/timeseries/timeseries_metadata',
         '$BUILD_DIR/mongo/db/timeseries/timeseries_options',
         'query/cluster_query',
         'write_ops/cluster_write_ops',
@@ -50,19 +49,19 @@ env.Library(
         'cluster_commands_helpers.cpp',
         'collection_uuid_mismatch.cpp',
         'multi_statement_transaction_requests_sender.cpp',
-        'router_role.cpp',
         'router_transactions_metrics.cpp',
         'router_transactions_stats.idl',
+        'router.cpp',
         'session_catalog_router.cpp',
         'stale_shard_version_helpers.cpp',
-        'transaction_router.cpp',
         'transaction_router_resource_yielder.cpp',
+        'transaction_router.cpp',
     ],
     LIBDEPS=[
         '$BUILD_DIR/mongo/db/commands/txn_cmd_request',
+        '$BUILD_DIR/mongo/db/curop',
         '$BUILD_DIR/mongo/db/logical_session_id_helpers',
         '$BUILD_DIR/mongo/db/pipeline/process_interface/mongo_process_interface',
-        '$BUILD_DIR/mongo/db/query/query_stats/query_stats',
         '$BUILD_DIR/mongo/db/repl/read_concern_args',
         '$BUILD_DIR/mongo/db/session_catalog',
         '$BUILD_DIR/mongo/db/shared_request_handling',
@@ -188,7 +187,6 @@ env.Library(
         'refine_collection_shard_key_coordinator_feature_flags.idl',
         'request_types/abort_reshard_collection.idl',
         'request_types/add_shard_request_type.cpp',
-        'request_types/get_stats_for_balancing.idl',
         'request_types/add_shard_to_zone_request_type.cpp',
         'request_types/auto_split_vector.idl',
         'request_types/balance_chunk_request_type.cpp',
@@ -239,7 +237,6 @@ env.Library(
         '$BUILD_DIR/mongo/db/index_commands_idl',
         '$BUILD_DIR/mongo/db/namespace_string',
         '$BUILD_DIR/mongo/db/query/query_request',
-        '$BUILD_DIR/mongo/db/query/query_shape/query_shape',
         '$BUILD_DIR/mongo/db/repl/optime',
         '$BUILD_DIR/mongo/db/server_options',
         '$BUILD_DIR/mongo/idl/feature_flag',
@@ -463,6 +460,7 @@ env.Library(
         '$BUILD_DIR/mongo/db/commands/server_status',
         '$BUILD_DIR/mongo/db/commands/server_status_core',
         '$BUILD_DIR/mongo/db/commands/server_status_servers',
+        '$BUILD_DIR/mongo/db/curop',
         '$BUILD_DIR/mongo/db/dbdirectclient',
         '$BUILD_DIR/mongo/db/ftdc/ftdc_mongos',
         '$BUILD_DIR/mongo/db/logical_session_cache',
@@ -470,7 +468,6 @@ env.Library(
         '$BUILD_DIR/mongo/db/logical_time_metadata_hook',
         '$BUILD_DIR/mongo/db/pipeline/process_interface/mongos_process_interface_factory',
         '$BUILD_DIR/mongo/db/process_health/fault_manager',
-        '$BUILD_DIR/mongo/db/query/query_stats/query_stats',
         '$BUILD_DIR/mongo/db/read_write_concern_defaults',
         '$BUILD_DIR/mongo/db/server_options',
         '$BUILD_DIR/mongo/db/server_options_base',
@@ -620,7 +617,6 @@ env.CppUnitTest(
         'catalog/type_mongos_test.cpp',
         'catalog/type_shard_test.cpp',
         'catalog/type_tags_test.cpp',
-        'chunks_test_util.cpp',
         'chunk_manager_index_bounds_test.cpp',
         'chunk_manager_query_test.cpp',
         'chunk_manager_targeter_test.cpp',
diff --git a/src/mongo/s/append_raw_responses_test.cpp b/src/mongo/s/append_raw_responses_test.cpp
index 01d26080e6e..9bbc161bfb1 100644
--- a/src/mongo/s/append_raw_responses_test.cpp
+++ b/src/mongo/s/append_raw_responses_test.cpp
@@ -165,9 +165,7 @@ protected:
             StaticCatalogClient(std::vector<ShardId> shardIds) : _shardIds(std::move(shardIds)) {}
 
             StatusWith<repl::OpTimeWith<std::vector<ShardType>>> getAllShards(
-                OperationContext* opCtx,
-                repl::ReadConcernLevel readConcern,
-                bool excludeDraining) override {
+                OperationContext* opCtx, repl::ReadConcernLevel readConcern) override {
                 std::vector<ShardType> shardTypes;
                 for (const auto& shardId : _shardIds) {
                     const ConnectionString cs = ConnectionString::forReplicaSet(
diff --git a/src/mongo/s/async_requests_sender.cpp b/src/mongo/s/async_requests_sender.cpp
index a5100472f69..1fceefc428e 100644
--- a/src/mongo/s/async_requests_sender.cpp
+++ b/src/mongo/s/async_requests_sender.cpp
@@ -37,7 +37,6 @@
 #include <memory>
 
 #include "mongo/client/remote_command_targeter.h"
-#include "mongo/db/curop.h"
 #include "mongo/executor/remote_command_request.h"
 #include "mongo/logv2/log.h"
 #include "mongo/rpc/get_status_from_command_result.h"
@@ -88,8 +87,6 @@ AsyncRequestsSender::AsyncRequestsSender(OperationContext* opCtx,
         // Kick off requests immediately.
         _remotes.emplace_back(this, request.shardId, request.cmdObj).executeRequest();
     }
-
-    CurOp::get(_opCtx)->ensureRecordRemoteOpWait();
 }
 
 AsyncRequestsSender::Response AsyncRequestsSender::next() noexcept {
@@ -120,22 +117,9 @@ AsyncRequestsSender::Response AsyncRequestsSender::next() noexcept {
             _resourceYielder->yield(_opCtx);
         }
 
-        auto curOp = CurOp::get(_opCtx);
-        // Calculating the total wait time for remote operations relies on the CurOp's timing
-        // measurement facility and we can't use such facility when the current operation is marked
-        // as done. Some commands such as 'analyzeShardKey' command may send remote operations using
-        // AsyncRequestsSender even after marking the current operation done and so we need to check
-        // whether the current operation is still in progress.
-        auto curOpInProgress = !curOp->isDone();
-        if (curOpInProgress) {
-            curOp->startRemoteOpWaitTimer();
-        }
         // Only wait for the next result without popping it, so an error unyielding doesn't
         // discard an already popped response.
         auto waitStatus = _responseQueue.waitForNonEmptyNoThrow(_opCtx);
-        if (curOpInProgress) {
-            curOp->stopRemoteOpWaitTimer();
-        }
 
         auto unyieldStatus =
             _resourceYielder ? _resourceYielder->unyieldNoThrow(_opCtx) : Status::OK();
@@ -186,10 +170,9 @@ AsyncRequestsSender::RemoteData::RemoteData(AsyncRequestsSender* ars,
                                             BSONObj cmdObj)
     : _ars(ars), _shardId(std::move(shardId)), _cmdObj(std::move(cmdObj)) {}
 
-SemiFuture<std::shared_ptr<Shard>> AsyncRequestsSender::RemoteData::getShard() noexcept {
-    return Grid::get(getGlobalServiceContext())
-        ->shardRegistry()
-        ->getShard(*_ars->_subBaton, _shardId);
+std::shared_ptr<Shard> AsyncRequestsSender::RemoteData::getShard() {
+    // TODO: Pass down an OperationContext* to use here.
+    return Grid::get(getGlobalServiceContext())->shardRegistry()->getShardNoReload(_shardId);
 }
 
 void AsyncRequestsSender::RemoteData::executeRequest() {
@@ -209,12 +192,7 @@ void AsyncRequestsSender::RemoteData::executeRequest() {
 
 auto AsyncRequestsSender::RemoteData::scheduleRequest()
     -> SemiFuture<RemoteCommandOnAnyCallbackArgs> {
-    return getShard()
-        .thenRunOn(*_ars->_subBaton)
-        .then([this](auto&& shard) {
-            return shard->getTargeter()->findHosts(_ars->_readPreference,
-                                                   CancellationToken::uncancelable());
-        })
+    return resolveShardIdToHostAndPorts(_ars->_readPreference)
         .thenRunOn(*_ars->_subBaton)
         .then([this](auto&& hostAndPorts) {
             _shardHostAndPort.emplace(hostAndPorts.front());
@@ -224,6 +202,17 @@ auto AsyncRequestsSender::RemoteData::scheduleRequest()
         .semi();
 }
 
+SemiFuture<std::vector<HostAndPort>> AsyncRequestsSender::RemoteData::resolveShardIdToHostAndPorts(
+    const ReadPreferenceSetting& readPref) {
+    const auto shard = getShard();
+    if (!shard) {
+        return Status(ErrorCodes::ShardNotFound,
+                      str::stream() << "Could not find shard " << _shardId);
+    }
+
+    return shard->getTargeter()->findHosts(readPref, CancellationToken::uncancelable());
+}
+
 auto AsyncRequestsSender::RemoteData::scheduleRemoteCommand(std::vector<HostAndPort>&& hostAndPorts)
     -> SemiFuture<RemoteCommandOnAnyCallbackArgs> {
     hangBeforeSchedulingRemoteCommand.executeIf(
@@ -289,47 +278,43 @@ auto AsyncRequestsSender::RemoteData::handleResponse(RemoteCommandOnAnyCallbackA
     }
 
     // There was an error with either the response or the command.
-    return getShard()
-        .thenRunOn(*_ars->_subBaton)
-        .then([this, status = std::move(status), rcr = std::move(rcr)](
-                  std::shared_ptr<mongo::Shard>&& shard) {
-            std::vector<HostAndPort> failedTargets;
-
-            if (rcr.response.target) {
-                failedTargets = {*rcr.response.target};
-            } else {
-                failedTargets = rcr.request.target;
-            }
+    auto shard = getShard();
+    if (!shard) {
+        uasserted(ErrorCodes::ShardNotFound, str::stream() << "Could not find shard " << _shardId);
+    } else {
+        std::vector<HostAndPort> failedTargets;
+
+        if (rcr.response.target) {
+            failedTargets = {*rcr.response.target};
+        } else {
+            failedTargets = rcr.request.target;
+        }
 
-            shard->updateReplSetMonitor(failedTargets.front(), status);
-            bool isStartingTransaction = _cmdObj.getField("startTransaction").booleanSafe();
-            if (!_ars->_stopRetrying &&
-                shard->isRetriableError(status.code(), _ars->_retryPolicy) &&
-                _retryCount < kMaxNumFailedHostRetryAttempts && !isStartingTransaction) {
-
-                LOGV2_DEBUG(
-                    4615637,
-                    1,
-                    "Command to remote {shardId} for hosts {hosts} failed with retryable error "
-                    "{error} and will be retried",
-                    "Command to remote shard failed with retryable error and will be retried",
-                    "shardId"_attr = _shardId,
-                    "hosts"_attr = failedTargets,
-                    "error"_attr = redact(status));
-                ++_retryCount;
-                _shardHostAndPort.reset();
-                // retry through recursion
-                return scheduleRequest();
-            }
+        shard->updateReplSetMonitor(failedTargets.front(), status);
+        bool isStartingTransaction = _cmdObj.getField("startTransaction").booleanSafe();
+        if (!_ars->_stopRetrying && shard->isRetriableError(status.code(), _ars->_retryPolicy) &&
+            _retryCount < kMaxNumFailedHostRetryAttempts && !isStartingTransaction) {
+
+            LOGV2_DEBUG(4615637,
+                        1,
+                        "Command to remote {shardId} for hosts {hosts} failed with retryable error "
+                        "{error} and will be retried",
+                        "Command to remote shard failed with retryable error and will be retried",
+                        "shardId"_attr = _shardId,
+                        "hosts"_attr = failedTargets,
+                        "error"_attr = redact(status));
+            ++_retryCount;
+            _shardHostAndPort.reset();
+            // retry through recursion
+            return scheduleRequest();
+        }
+    }
 
-            // Status' in the response.status field that aren't retried get converted to top level
-            // errors
-            uassertStatusOK(rcr.response.status);
+    // Status' in the response.status field that aren't retried get converted to top level errors
+    uassertStatusOK(rcr.response.status);
 
-            // We're not okay (on the remote), but still not going to retry
-            return Future<RemoteCommandOnAnyCallbackArgs>::makeReady(std::move(rcr)).semi();
-        })
-        .semi();
+    // We're not okay (on the remote), but still not going to retry
+    return std::move(rcr);
 };
 
 }  // namespace mongo
diff --git a/src/mongo/s/async_requests_sender.h b/src/mongo/s/async_requests_sender.h
index 27d22bc5511..432227356cc 100644
--- a/src/mongo/s/async_requests_sender.h
+++ b/src/mongo/s/async_requests_sender.h
@@ -179,15 +179,9 @@ private:
         RemoteData(AsyncRequestsSender* ars, ShardId shardId, BSONObj cmdObj);
 
         /**
-         * Returns a SemiFuture containing a shard object associated with this remote.
-         *
-         * This will return a SemiFuture with a ShardNotFound error status in case the shard is not
-         * found.
-         *
-         * Additionally this call can trigger a refresh of the ShardRegistry so it could possibly
-         * return other network error status related to the refresh.
+         * Returns the Shard object associated with this remote.
          */
-        SemiFuture<std::shared_ptr<Shard>> getShard() noexcept;
+        std::shared_ptr<Shard> getShard();
 
         /**
          * Returns true if we've already queued a response from the remote.
diff --git a/src/mongo/s/catalog/sharding_catalog_client.h b/src/mongo/s/catalog/sharding_catalog_client.h
index 41057194e3a..05ea0bf1658 100644
--- a/src/mongo/s/catalog/sharding_catalog_client.h
+++ b/src/mongo/s/catalog/sharding_catalog_client.h
@@ -131,14 +131,11 @@ public:
     /**
      * Retrieves all collections under a specified database (or in the system). If the dbName
      * parameter is empty, returns all collections.
-     *
-     * @param sort Fields to use for sorting the results. If empty, no sorting is performed.
      */
     virtual std::vector<CollectionType> getCollections(
         OperationContext* opCtx,
         StringData db,
-        repl::ReadConcernLevel readConcernLevel = repl::ReadConcernLevel::kMajorityReadConcern,
-        const BSONObj& sort = BSONObj()) = 0;
+        repl::ReadConcernLevel readConcernLevel = repl::ReadConcernLevel::kMajorityReadConcern) = 0;
 
     /**
      * Returns the set of collections for the specified database, which have been marked as sharded.
@@ -206,15 +203,11 @@ public:
                                                                    const NamespaceString& nss) = 0;
 
     /**
-     * Retrieves the list of shards in this sharded cluster. If `excludeDraining` is set to `false`
-     * (default), it retrieves all shards. Otherwise, it retrieves only shards that are not
-     * draining.
+     * Retrieves all shards in this sharded cluster.
      * Returns a !OK status if an error occurs.
      */
     virtual StatusWith<repl::OpTimeWith<std::vector<ShardType>>> getAllShards(
-        OperationContext* opCtx,
-        repl::ReadConcernLevel readConcern,
-        bool excludeDraining = false) = 0;
+        OperationContext* opCtx, repl::ReadConcernLevel readConcern) = 0;
 
     /**
      * Runs a user management command on the config servers. Do not use for general write command
@@ -288,22 +281,15 @@ public:
                                                      repl::ReadConcernLevel readConcern) = 0;
 
     /**
-     * Returns internal keys for the given purpose and have an expiresAt value greater than
-     * newerThanThis.
+     * Returns keys for the given purpose and with an expiresAt value greater than newerThanThis.
      */
-    virtual StatusWith<std::vector<KeysCollectionDocument>> getNewInternalKeys(
+    virtual StatusWith<std::vector<KeysCollectionDocument>> getNewKeys(
         OperationContext* opCtx,
         StringData purpose,
         const LogicalTime& newerThanThis,
         repl::ReadConcernLevel readConcernLevel) = 0;
 
     /**
-     * Returns all external (i.e. validation-only) keys for the given purpose.
-     */
-    virtual StatusWith<std::vector<ExternalKeysCollectionDocument>> getAllExternalKeys(
-        OperationContext* opCtx, StringData purpose, repl::ReadConcernLevel readConcernLevel) = 0;
-
-    /**
      * Directly inserts a document in the specified namespace on the config server. The document
      * must have an _id index. Must only be used for insertions in the 'config' database.
      *
@@ -315,6 +301,19 @@ public:
                                         const WriteConcernOptions& writeConcern) = 0;
 
     /**
+     * Directly inserts documents in the specified namespace on the config server. Inserts said
+     * documents using a retryable write. Underneath, a session is created and destroyed -- this
+     * ad-hoc session creation strategy should never be used outside of specific, non-performant
+     * code paths.
+     *
+     * Must only be used for insertions in the 'config' database.
+     */
+    virtual void insertConfigDocumentsAsRetryableWrite(OperationContext* opCtx,
+                                                       const NamespaceString& nss,
+                                                       std::vector<BSONObj> docs,
+                                                       const WriteConcernOptions& writeConcern) = 0;
+
+    /**
      * Updates a single document in the specified namespace on the config server. Must only be used
      * for updates to the 'config' database.
      *
diff --git a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
index 38949060bf1..bf98a08c7aa 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
@@ -102,6 +102,37 @@ void toBatchError(const Status& status, BatchedCommandResponse* response) {
     response->setStatus(status);
 }
 
+void sendRetryableWriteBatchRequestToConfig(OperationContext* opCtx,
+                                            const NamespaceString& nss,
+                                            std::vector<BSONObj>& docs,
+                                            TxnNumber txnNumber,
+                                            const WriteConcernOptions& writeConcern) {
+    auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
+
+    BatchedCommandRequest request([&] {
+        write_ops::InsertCommandRequest insertOp(nss);
+        insertOp.setDocuments(docs);
+        return insertOp;
+    }());
+    request.setWriteConcern(writeConcern.toBSON());
+
+    BSONObj cmdObj = request.toBSON();
+    BSONObjBuilder bob(cmdObj);
+    bob.append(OperationSessionInfo::kTxnNumberFieldName, txnNumber);
+
+    BatchedCommandResponse batchResponse;
+    auto response = configShard->runCommand(opCtx,
+                                            ReadPreferenceSetting{ReadPreference::PrimaryOnly},
+                                            nss.db().toString(),
+                                            bob.obj(),
+                                            Shard::kDefaultConfigCommandTimeout,
+                                            Shard::RetryPolicy::kIdempotent);
+
+    auto writeStatus = Shard::CommandResponse::processBatchWriteResponse(response, &batchResponse);
+
+    uassertStatusOK(batchResponse.toStatus());
+    uassertStatusOK(writeStatus);
+}
 
 AggregateCommandRequest makeCollectionAndChunksAggregation(OperationContext* opCtx,
                                                            const NamespaceString& nss,
@@ -271,45 +302,6 @@ AggregateCommandRequest makeCollectionAndChunksAggregation(OperationContext* opC
     return AggregateCommandRequest(CollectionType::ConfigNS, std::move(serializedPipeline));
 }
 
-/**
- * Returns keys for the given purpose and have an expiresAt value greater than newerThanThis on the
- * given shard.
- */
-template <typename KeyDocumentType>
-StatusWith<std::vector<KeyDocumentType>> _getNewKeys(OperationContext* opCtx,
-                                                     std::shared_ptr<Shard> shard,
-                                                     const NamespaceString& nss,
-                                                     StringData purpose,
-                                                     const LogicalTime& newerThanThis,
-                                                     repl::ReadConcernLevel readConcernLevel) {
-    BSONObjBuilder queryBuilder;
-    queryBuilder.append("purpose", purpose);
-    queryBuilder.append("expiresAt", BSON("$gt" << newerThanThis.asTimestamp()));
-
-    auto findStatus = shard->exhaustiveFindOnConfig(opCtx,
-                                                    kConfigReadSelector,
-                                                    readConcernLevel,
-                                                    nss,
-                                                    queryBuilder.obj(),
-                                                    BSON("expiresAt" << 1),
-                                                    boost::none);
-    if (!findStatus.isOK()) {
-        return findStatus.getStatus();
-    }
-    const auto& objs = findStatus.getValue().docs;
-
-    std::vector<KeyDocumentType> keyDocs;
-    keyDocs.reserve(objs.size());
-    for (auto&& obj : objs) {
-        try {
-            keyDocs.push_back(KeyDocumentType::parse(IDLParserErrorContext("keyDoc"), obj));
-        } catch (...) {
-            return exceptionToStatus();
-        }
-    }
-    return keyDocs;
-}
-
 }  // namespace
 
 ShardingCatalogClientImpl::ShardingCatalogClientImpl() = default;
@@ -465,10 +457,7 @@ CollectionType ShardingCatalogClientImpl::getCollection(OperationContext* opCtx,
 }
 
 std::vector<CollectionType> ShardingCatalogClientImpl::getCollections(
-    OperationContext* opCtx,
-    StringData dbName,
-    repl::ReadConcernLevel readConcernLevel,
-    const BSONObj& sort) {
+    OperationContext* opCtx, StringData dbName, repl::ReadConcernLevel readConcernLevel) {
     BSONObjBuilder b;
     if (!dbName.empty())
         b.appendRegex(CollectionType::kNssFieldName,
@@ -480,7 +469,7 @@ std::vector<CollectionType> ShardingCatalogClientImpl::getCollections(
                                                             readConcernLevel,
                                                             CollectionType::ConfigNS,
                                                             b.obj(),
-                                                            sort,
+                                                            BSONObj(),
                                                             boost::none))
                         .value;
     std::vector<CollectionType> collections;
@@ -493,7 +482,7 @@ std::vector<CollectionType> ShardingCatalogClientImpl::getCollections(
 
 std::vector<NamespaceString> ShardingCatalogClientImpl::getAllShardedCollectionsForDb(
     OperationContext* opCtx, StringData dbName, repl::ReadConcernLevel readConcern) {
-    auto collectionsOnConfig = getCollections(opCtx, dbName, readConcern, BSONObj());
+    auto collectionsOnConfig = getCollections(opCtx, dbName, readConcern);
 
     std::vector<NamespaceString> collectionsToReturn;
     collectionsToReturn.reserve(collectionsOnConfig.size());
@@ -773,35 +762,38 @@ StatusWith<std::vector<TagsType>> ShardingCatalogClientImpl::getTagsForCollectio
 }
 
 StatusWith<repl::OpTimeWith<std::vector<ShardType>>> ShardingCatalogClientImpl::getAllShards(
-    OperationContext* opCtx, repl::ReadConcernLevel readConcern, bool excludeDraining) {
-    const auto& findRes = uassertStatusOK(
-        _exhaustiveFindOnConfig(opCtx,
-                                kConfigReadSelector,
-                                readConcern,
-                                ShardType::ConfigNS,
-                                excludeDraining ? BSON(ShardType::draining.ne(true)) : BSONObj(),
-                                BSONObj() /* No sorting */,
-                                boost::none /* No limit */));
+    OperationContext* opCtx, repl::ReadConcernLevel readConcern) {
+    auto findStatus = _exhaustiveFindOnConfig(opCtx,
+                                              kConfigReadSelector,
+                                              readConcern,
+                                              ShardType::ConfigNS,
+                                              BSONObj(),     // no query filter
+                                              BSONObj(),     // no sort
+                                              boost::none);  // no limit
+    if (!findStatus.isOK()) {
+        return findStatus.getStatus();
+    }
 
     std::vector<ShardType> shards;
-    shards.reserve(findRes.value.size());
-    for (const BSONObj& doc : findRes.value) {
+    shards.reserve(findStatus.getValue().value.size());
+    for (const BSONObj& doc : findStatus.getValue().value) {
         auto shardRes = ShardType::fromBSON(doc);
         if (!shardRes.isOK()) {
             return shardRes.getStatus().withContext(stream()
                                                     << "Failed to parse shard document " << doc);
         }
 
-        ShardType& shard = shardRes.getValue();
-        if (const Status validateStatus = shard.validate(); !validateStatus.isOK()) {
-            return validateStatus.withContext(str::stream()
+        Status validateStatus = shardRes.getValue().validate();
+        if (!validateStatus.isOK()) {
+            return validateStatus.withContext(stream()
                                               << "Failed to validate shard document " << doc);
         }
 
-        shards.push_back(std::move(shard));
+        shards.push_back(shardRes.getValue());
     }
 
-    return repl::OpTimeWith<std::vector<ShardType>>{std::move(shards), findRes.opTime};
+    return repl::OpTimeWith<std::vector<ShardType>>{std::move(shards),
+                                                    findStatus.getValue().opTime};
 }
 
 Status ShardingCatalogClientImpl::runUserManagementWriteCommand(OperationContext* opCtx,
@@ -1011,14 +1003,12 @@ Status ShardingCatalogClientImpl::insertConfigDocument(OperationContext* opCtx,
         insertOp.setDocuments({doc});
         return insertOp;
     }());
+    request.setWriteConcern(writeConcern.toBSON());
 
     auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
     for (int retry = 1; retry <= kMaxWriteRetry; retry++) {
-        auto response = configShard->runBatchWriteCommand(opCtx,
-                                                          Shard::kDefaultConfigCommandTimeout,
-                                                          request,
-                                                          writeConcern,
-                                                          Shard::RetryPolicy::kNoRetry);
+        auto response = configShard->runBatchWriteCommand(
+            opCtx, Shard::kDefaultConfigCommandTimeout, request, Shard::RetryPolicy::kNoRetry);
 
         Status status = response.toStatus();
 
@@ -1073,6 +1063,49 @@ Status ShardingCatalogClientImpl::insertConfigDocument(OperationContext* opCtx,
     MONGO_UNREACHABLE;
 }
 
+void ShardingCatalogClientImpl::insertConfigDocumentsAsRetryableWrite(
+    OperationContext* opCtx,
+    const NamespaceString& nss,
+    std::vector<BSONObj> docs,
+    const WriteConcernOptions& writeConcern) {
+    invariant(nss.db() == NamespaceString::kAdminDb || nss.db() == NamespaceString::kConfigDb);
+
+    AlternativeSessionRegion asr(opCtx);
+    TxnNumber currentTxnNumber = 0;
+
+    std::vector<BSONObj> workingBatch;
+    size_t workingBatchItemSize = 0;
+    int workingBatchDocSize = 0;
+
+    while (!docs.empty()) {
+        BSONObj toAdd = docs.back();
+        docs.pop_back();
+
+        const int docSizePlusOverhead =
+            toAdd.objsize() + write_ops::kRetryableAndTxnBatchWriteBSONSizeOverhead;
+        // Check if pushing this object will exceed the batch size limit or the max object size
+        if ((workingBatchItemSize + 1 > write_ops::kMaxWriteBatchSize) ||
+            (workingBatchDocSize + docSizePlusOverhead > BSONObjMaxUserSize)) {
+            sendRetryableWriteBatchRequestToConfig(
+                asr.opCtx(), nss, workingBatch, currentTxnNumber, writeConcern);
+            ++currentTxnNumber;
+
+            workingBatch.clear();
+            workingBatchItemSize = 0;
+            workingBatchDocSize = 0;
+        }
+
+        workingBatch.push_back(toAdd);
+        ++workingBatchItemSize;
+        workingBatchDocSize += docSizePlusOverhead;
+    }
+
+    if (!workingBatch.empty()) {
+        sendRetryableWriteBatchRequestToConfig(
+            asr.opCtx(), nss, workingBatch, currentTxnNumber, writeConcern);
+    }
+}
+
 StatusWith<bool> ShardingCatalogClientImpl::updateConfigDocument(
     OperationContext* opCtx,
     const NamespaceString& nss,
@@ -1117,10 +1150,11 @@ StatusWith<bool> ShardingCatalogClientImpl::_updateConfigDocument(
         }()});
         return updateOp;
     }());
+    request.setWriteConcern(writeConcern.toBSON());
 
     auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
     auto response = configShard->runBatchWriteCommand(
-        opCtx, maxTimeMs, request, writeConcern, Shard::RetryPolicy::kIdempotent);
+        opCtx, maxTimeMs, request, Shard::RetryPolicy::kIdempotent);
 
     Status status = response.toStatus();
     if (!status.isOK()) {
@@ -1152,13 +1186,11 @@ Status ShardingCatalogClientImpl::removeConfigDocuments(OperationContext* opCtx,
         }()});
         return deleteOp;
     }());
+    request.setWriteConcern(writeConcern.toBSON());
 
     auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
-    auto response = configShard->runBatchWriteCommand(opCtx,
-                                                      Shard::kDefaultConfigCommandTimeout,
-                                                      request,
-                                                      writeConcern,
-                                                      Shard::RetryPolicy::kIdempotent);
+    auto response = configShard->runBatchWriteCommand(
+        opCtx, Shard::kDefaultConfigCommandTimeout, request, Shard::RetryPolicy::kIdempotent);
     return response.toStatus();
 }
 
@@ -1181,32 +1213,41 @@ StatusWith<repl::OpTimeWith<vector<BSONObj>>> ShardingCatalogClientImpl::_exhaus
                                              response.getValue().opTime);
 }
 
-StatusWith<std::vector<KeysCollectionDocument>> ShardingCatalogClientImpl::getNewInternalKeys(
+StatusWith<std::vector<KeysCollectionDocument>> ShardingCatalogClientImpl::getNewKeys(
     OperationContext* opCtx,
     StringData purpose,
     const LogicalTime& newerThanThis,
     repl::ReadConcernLevel readConcernLevel) {
-    auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
-    return _getNewKeys<KeysCollectionDocument>(opCtx,
-                                               configShard,
-                                               NamespaceString::kKeysCollectionNamespace,
-                                               purpose,
-                                               newerThanThis,
-                                               readConcernLevel);
-}
+    auto config = Grid::get(opCtx)->shardRegistry()->getConfigShard();
 
-StatusWith<std::vector<ExternalKeysCollectionDocument>>
-ShardingCatalogClientImpl::getAllExternalKeys(OperationContext* opCtx,
-                                              StringData purpose,
-                                              repl::ReadConcernLevel readConcernLevel) {
-    auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
-    return _getNewKeys<ExternalKeysCollectionDocument>(
-        opCtx,
-        configShard,
-        NamespaceString::kExternalKeysCollectionNamespace,
-        purpose,
-        LogicalTime(),
-        readConcernLevel);
+    BSONObjBuilder queryBuilder;
+    queryBuilder.append("purpose", purpose);
+    queryBuilder.append("expiresAt", BSON("$gt" << newerThanThis.asTimestamp()));
+
+    auto findStatus = config->exhaustiveFindOnConfig(opCtx,
+                                                     kConfigReadSelector,
+                                                     readConcernLevel,
+                                                     NamespaceString::kKeysCollectionNamespace,
+                                                     queryBuilder.obj(),
+                                                     BSON("expiresAt" << 1),
+                                                     boost::none);
+
+    if (!findStatus.isOK()) {
+        return findStatus.getStatus();
+    }
+
+    const auto& keyDocs = findStatus.getValue().docs;
+    std::vector<KeysCollectionDocument> keys;
+    keys.reserve(keyDocs.size());
+    for (auto&& keyDoc : keyDocs) {
+        try {
+            keys.push_back(KeysCollectionDocument::parse(IDLParserErrorContext("keyDoc"), keyDoc));
+        } catch (...) {
+            return exceptionToStatus();
+        }
+    }
+
+    return keys;
 }
 
 }  // namespace mongo
diff --git a/src/mongo/s/catalog/sharding_catalog_client_impl.h b/src/mongo/s/catalog/sharding_catalog_client_impl.h
index e0aa93ad3b6..99c86ef03a1 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_impl.h
+++ b/src/mongo/s/catalog/sharding_catalog_client_impl.h
@@ -82,8 +82,7 @@ public:
 
     std::vector<CollectionType> getCollections(OperationContext* opCtx,
                                                StringData db,
-                                               repl::ReadConcernLevel readConcernLevel,
-                                               const BSONObj& sort) override;
+                                               repl::ReadConcernLevel readConcernLevel) override;
 
     std::vector<NamespaceString> getAllShardedCollectionsForDb(
         OperationContext* opCtx, StringData dbName, repl::ReadConcernLevel readConcern) override;
@@ -112,7 +111,7 @@ public:
                                                            const NamespaceString& nss) override;
 
     StatusWith<repl::OpTimeWith<std::vector<ShardType>>> getAllShards(
-        OperationContext* opCtx, repl::ReadConcernLevel readConcern, bool excludeDraining) override;
+        OperationContext* opCtx, repl::ReadConcernLevel readConcern) override;
 
     Status runUserManagementWriteCommand(OperationContext* opCtx,
                                          StringData commandName,
@@ -144,6 +143,11 @@ public:
                                 const BSONObj& doc,
                                 const WriteConcernOptions& writeConcern) override;
 
+    void insertConfigDocumentsAsRetryableWrite(OperationContext* opCtx,
+                                               const NamespaceString& nss,
+                                               std::vector<BSONObj> docs,
+                                               const WriteConcernOptions& writeConcern) override;
+
     StatusWith<bool> updateConfigDocument(OperationContext* opCtx,
                                           const NamespaceString& nss,
                                           const BSONObj& query,
@@ -165,17 +169,12 @@ public:
                                  const WriteConcernOptions& writeConcern,
                                  boost::optional<BSONObj> hint = boost::none) override;
 
-    StatusWith<std::vector<KeysCollectionDocument>> getNewInternalKeys(
+    StatusWith<std::vector<KeysCollectionDocument>> getNewKeys(
         OperationContext* opCtx,
         StringData purpose,
         const LogicalTime& newerThanThis,
         repl::ReadConcernLevel readConcernLevel) override;
 
-    StatusWith<std::vector<ExternalKeysCollectionDocument>> getAllExternalKeys(
-        OperationContext* opCtx,
-        StringData purpose,
-        repl::ReadConcernLevel readConcernLevel) override;
-
 private:
     /**
      * Updates a single document (if useMultiUpdate is false) or multiple documents (if
diff --git a/src/mongo/s/catalog/sharding_catalog_client_mock.cpp b/src/mongo/s/catalog/sharding_catalog_client_mock.cpp
index 7f19157811b..3ad6ab3f54a 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_mock.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_mock.cpp
@@ -69,10 +69,7 @@ CollectionType ShardingCatalogClientMock::getCollection(OperationContext* opCtx,
 }
 
 std::vector<CollectionType> ShardingCatalogClientMock::getCollections(
-    OperationContext* opCtx,
-    StringData dbName,
-    repl::ReadConcernLevel readConcernLevel,
-    const BSONObj& sort) {
+    OperationContext* opCtx, StringData dbName, repl::ReadConcernLevel readConcernLevel) {
     uasserted(ErrorCodes::InternalError, "Method not implemented");
 }
 
@@ -113,7 +110,7 @@ StatusWith<std::vector<TagsType>> ShardingCatalogClientMock::getTagsForCollectio
 }
 
 StatusWith<repl::OpTimeWith<std::vector<ShardType>>> ShardingCatalogClientMock::getAllShards(
-    OperationContext* opCtx, repl::ReadConcernLevel readConcern, bool excludeDraining) {
+    OperationContext* opCtx, repl::ReadConcernLevel readConcern) {
     return {ErrorCodes::InternalError, "Method not implemented"};
 }
 
@@ -152,6 +149,12 @@ Status ShardingCatalogClientMock::insertConfigDocument(OperationContext* opCtx,
     return {ErrorCodes::InternalError, "Method not implemented"};
 }
 
+void ShardingCatalogClientMock::insertConfigDocumentsAsRetryableWrite(
+    OperationContext* opCtx,
+    const NamespaceString& nss,
+    std::vector<BSONObj> docs,
+    const WriteConcernOptions& writeConcern) {}
+
 StatusWith<bool> ShardingCatalogClientMock::updateConfigDocument(
     OperationContext* opCtx,
     const NamespaceString& nss,
@@ -188,7 +191,7 @@ Status ShardingCatalogClientMock::createDatabase(OperationContext* opCtx,
     return {ErrorCodes::InternalError, "Method not implemented"};
 }
 
-StatusWith<std::vector<KeysCollectionDocument>> ShardingCatalogClientMock::getNewInternalKeys(
+StatusWith<std::vector<KeysCollectionDocument>> ShardingCatalogClientMock::getNewKeys(
     OperationContext* opCtx,
     StringData purpose,
     const LogicalTime& newerThanThis,
@@ -196,13 +199,6 @@ StatusWith<std::vector<KeysCollectionDocument>> ShardingCatalogClientMock::getNe
     return {ErrorCodes::InternalError, "Method not implemented"};
 }
 
-StatusWith<std::vector<ExternalKeysCollectionDocument>>
-ShardingCatalogClientMock::getAllExternalKeys(OperationContext* opCtx,
-                                              StringData purpose,
-                                              repl::ReadConcernLevel readConcernLevel) {
-    return {ErrorCodes::InternalError, "Method not implemented"};
-}
-
 StatusWith<repl::OpTimeWith<std::vector<BSONObj>>>
 ShardingCatalogClientMock::_exhaustiveFindOnConfig(OperationContext* opCtx,
                                                    const ReadPreferenceSetting& readPref,
diff --git a/src/mongo/s/catalog/sharding_catalog_client_mock.h b/src/mongo/s/catalog/sharding_catalog_client_mock.h
index 4cbfd759604..fdab949c024 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_mock.h
+++ b/src/mongo/s/catalog/sharding_catalog_client_mock.h
@@ -58,8 +58,7 @@ public:
 
     std::vector<CollectionType> getCollections(OperationContext* opCtx,
                                                StringData db,
-                                               repl::ReadConcernLevel readConcernLevel,
-                                               const BSONObj& sort) override;
+                                               repl::ReadConcernLevel readConcernLevel) override;
 
     std::vector<NamespaceString> getAllShardedCollectionsForDb(
         OperationContext* opCtx, StringData dbName, repl::ReadConcernLevel readConcern) override;
@@ -87,7 +86,7 @@ public:
                                                            const NamespaceString& nss) override;
 
     StatusWith<repl::OpTimeWith<std::vector<ShardType>>> getAllShards(
-        OperationContext* opCtx, repl::ReadConcernLevel readConcern, bool excludeDraining) override;
+        OperationContext* opCtx, repl::ReadConcernLevel readConcern) override;
 
     Status runUserManagementWriteCommand(OperationContext* opCtx,
                                          StringData commandName,
@@ -121,6 +120,11 @@ public:
                                 const BSONObj& doc,
                                 const WriteConcernOptions& writeConcern) override;
 
+    void insertConfigDocumentsAsRetryableWrite(OperationContext* opCtx,
+                                               const NamespaceString& nss,
+                                               std::vector<BSONObj> docs,
+                                               const WriteConcernOptions& writeConcern) override;
+
     StatusWith<bool> updateConfigDocument(OperationContext* opCtx,
                                           const NamespaceString& nss,
                                           const BSONObj& query,
@@ -144,17 +148,12 @@ public:
 
     Status createDatabase(OperationContext* opCtx, StringData dbName, ShardId primaryShard);
 
-    StatusWith<std::vector<KeysCollectionDocument>> getNewInternalKeys(
+    StatusWith<std::vector<KeysCollectionDocument>> getNewKeys(
         OperationContext* opCtx,
         StringData purpose,
         const LogicalTime& newerThanThis,
         repl::ReadConcernLevel readConcernLevel) override;
 
-    StatusWith<std::vector<ExternalKeysCollectionDocument>> getAllExternalKeys(
-        OperationContext* opCtx,
-        StringData purpose,
-        repl::ReadConcernLevel readConcernLevel) override;
-
 private:
     StatusWith<repl::OpTimeWith<std::vector<BSONObj>>> _exhaustiveFindOnConfig(
         OperationContext* opCtx,
diff --git a/src/mongo/s/catalog/sharding_catalog_client_test.cpp b/src/mongo/s/catalog/sharding_catalog_client_test.cpp
index 80967107ff6..1c9e8bca3b9 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_test.cpp
@@ -361,40 +361,6 @@ TEST_F(ShardingCatalogClientTest, GetAllShardsWithInvalidShard) {
     future.default_timed_get();
 }
 
-TEST_F(ShardingCatalogClientTest, GetAllShardsWithDrainingShard) {
-    configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
-
-    auto future = launchAsync([this]() {
-        const auto shards =
-            assertGet(catalogClient()->getAllShards(operationContext(),
-                                                    repl::ReadConcernLevel::kMajorityReadConcern,
-                                                    true /* excludeDraining */));
-        return shards.value;
-    });
-
-    onFindCommand([this](const RemoteCommandRequest& request) {
-        ASSERT_BSONOBJ_EQ(getReplSecondaryOkMetadata(),
-                          rpc::TrackingMetadata::removeTrackingData(request.metadata));
-
-        const auto opMsg = OpMsgRequest::fromDBAndBody(request.dbname, request.cmdObj);
-        const auto query = query_request_helper::makeFromFindCommandForTests(opMsg.body);
-
-        ASSERT_EQ(query->getNamespaceOrUUID().nss().value_or(NamespaceString()),
-                  ShardType::ConfigNS);
-        ASSERT_BSONOBJ_EQ(query->getFilter(), BSON(ShardType::draining.ne(true)));
-        ASSERT_BSONOBJ_EQ(query->getSort(), BSONObj());
-        ASSERT_FALSE(query->getLimit().has_value());
-
-        checkReadConcern(request.cmdObj,
-                         VectorClock::kInitialComponentTime.asTimestamp(),
-                         repl::OpTime::kUninitializedTerm);
-
-        return vector<BSONObj>{};
-    });
-
-    future.default_timed_get();
-}
-
 TEST_F(ShardingCatalogClientTest, GetChunksForNSWithSortAndLimit) {
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
@@ -1385,10 +1351,10 @@ TEST_F(ShardingCatalogClientTest, GetNewKeys) {
     repl::ReadConcernLevel readConcernLevel(repl::ReadConcernLevel::kMajorityReadConcern);
 
     auto future = launchAsync([this, purpose, currentTime, readConcernLevel] {
-        auto swKeys = catalogClient()->getNewInternalKeys(
-            operationContext(), purpose, currentTime, readConcernLevel);
-        ASSERT_OK(swKeys.getStatus());
-        return swKeys.getValue();
+        auto status =
+            catalogClient()->getNewKeys(operationContext(), purpose, currentTime, readConcernLevel);
+        ASSERT_OK(status.getStatus());
+        return status.getValue();
     });
 
     LogicalTime dummyTime(Timestamp(9876, 5432));
@@ -1450,10 +1416,10 @@ TEST_F(ShardingCatalogClientTest, GetNewKeysWithEmptyCollection) {
     repl::ReadConcernLevel readConcernLevel(repl::ReadConcernLevel::kMajorityReadConcern);
 
     auto future = launchAsync([this, purpose, currentTime, readConcernLevel] {
-        auto swKeys = catalogClient()->getNewInternalKeys(
-            operationContext(), purpose, currentTime, readConcernLevel);
-        ASSERT_OK(swKeys.getStatus());
-        return swKeys.getValue();
+        auto status =
+            catalogClient()->getNewKeys(operationContext(), purpose, currentTime, readConcernLevel);
+        ASSERT_OK(status.getStatus());
+        return status.getValue();
     });
 
     onFindCommand([this](const RemoteCommandRequest& request) {
diff --git a/src/mongo/s/catalog/type_chunk.cpp b/src/mongo/s/catalog/type_chunk.cpp
index 39b4295f66f..61c964af93d 100644
--- a/src/mongo/s/catalog/type_chunk.cpp
+++ b/src/mongo/s/catalog/type_chunk.cpp
@@ -88,15 +88,6 @@ Status extractObject(const BSONObj& obj, const std::string& fieldName, BSONEleme
     return Status::OK();
 }
 
-bool allElementsAreMaxKey(const BSONObj& obj) {
-    for (auto&& elem : obj) {
-        if (elem.type() != MaxKey) {
-            return false;
-        }
-    }
-    return true;
-}
-
 }  // namespace
 
 ChunkRange::ChunkRange(BSONObj minKey, BSONObj maxKey)
@@ -133,8 +124,7 @@ StatusWith<ChunkRange> ChunkRange::fromBSON(const BSONObj& obj) {
 }
 
 bool ChunkRange::containsKey(const BSONObj& key) const {
-    return (_minKey.woCompare(key) <= 0 && key.woCompare(_maxKey) < 0) ||
-        MONGO_unlikely(allElementsAreMaxKey(key) && key.binaryEqual(_maxKey));
+    return _minKey.woCompare(key) <= 0 && key.woCompare(_maxKey) < 0;
 }
 
 void ChunkRange::append(BSONObjBuilder* builder) const {
@@ -597,9 +587,8 @@ Status ChunkType::validate() const {
     if (!_history.empty()) {
         if (_history.front().getShard() != *_shard) {
             return {ErrorCodes::BadValue,
-                    str::stream() << "Latest entry of chunk history refer to shard "
-                                  << _history.front().getShard()
-                                  << " that does not match the current shard " << *_shard};
+                    str::stream() << "History contains an invalid shard "
+                                  << _history.front().getShard()};
         }
     }
 
diff --git a/src/mongo/s/catalog/type_chunk.h b/src/mongo/s/catalog/type_chunk.h
index 0b24977cfba..be05f7af42f 100644
--- a/src/mongo/s/catalog/type_chunk.h
+++ b/src/mongo/s/catalog/type_chunk.h
@@ -137,9 +137,6 @@ private:
 
 class ChunkHistory : public ChunkHistoryBase {
 public:
-    using ChunkHistoryBase::serialize;
-    using ChunkHistoryBase::toBSON;
-
     ChunkHistory() : ChunkHistoryBase() {}
     ChunkHistory(mongo::Timestamp ts, mongo::ShardId shard) : ChunkHistoryBase() {
         setValidAfter(std::move(ts));
diff --git a/src/mongo/s/catalog/type_chunk_test.cpp b/src/mongo/s/catalog/type_chunk_test.cpp
index 3de5d37ce88..52c172a529a 100644
--- a/src/mongo/s/catalog/type_chunk_test.cpp
+++ b/src/mongo/s/catalog/type_chunk_test.cpp
@@ -352,69 +352,6 @@ TEST(ChunkRange, Union) {
            target.unionWith(ChunkRange(BSON("x" << 9), BSON("x" << 15))));
 }
 
-TEST(ChunkRange, ContainsKey) {
-    auto target = ChunkRange(BSON("x" << 5), BSON("x" << 10));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MINKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 2)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 10)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 15)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY)));
-
-    target = ChunkRange(BSON("x" << MINKEY), BSON("x" << 5));
-    ASSERT_TRUE(target.containsKey(BSON("x" << MINKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 2)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 5)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 10)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY)));
-
-    target = ChunkRange(BSON("x" << 5), BSON("x" << MAXKEY));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MINKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 2)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 10)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << MAXKEY)));
-}
-
-TEST(ChunkRange, ContainsKeyCompound) {
-    auto target = ChunkRange(BSON("x" << 5 << "y" << 100), BSON("x" << 10 << "y" << 120));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MINKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MINKEY << "y" << 110)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 2)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 2 << "y" << 110)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 5)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 5 << "y" << 0)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5 << "y" << 120)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5 << "y" << MAXKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5 << "y" << 100)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5 << "y" << 110)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7 << "y" << MINKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7 << "y" << 100)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7 << "y" << 110)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7 << "y" << 120)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 7 << "y" << MAXKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 10)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 10 << "y" << 0)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 10 << "y" << 100)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 10 << "y" << 110)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 10 << "y" << 120)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 10 << "y" << MAXKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 15)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY << "y" << 0)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY << "y" << 100)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY << "y" << 110)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY << "y" << 120)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MAXKEY << "y" << MAXKEY)));
-
-    target = ChunkRange(BSON("x" << 5 << "y" << 5), BSON("x" << MAXKEY << "y" << MAXKEY));
-    ASSERT_FALSE(target.containsKey(BSON("x" << MINKEY << "y" << MAXKEY)));
-    ASSERT_FALSE(target.containsKey(BSON("x" << 2 << "y" << MAXKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << 5 << "y" << MAXKEY)));
-    ASSERT_TRUE(target.containsKey(BSON("x" << MAXKEY << "y" << MAXKEY)));
-}
-
 TEST(ChunkRange, MinGreaterThanMaxShouldError) {
     auto parseStatus =
         ChunkRange::fromBSON(BSON("min" << BSON("x" << 10) << "max" << BSON("x" << 0)));
diff --git a/src/mongo/s/catalog/type_collection.cpp b/src/mongo/s/catalog/type_collection.cpp
index 320382f9e98..5cc64eca8b5 100644
--- a/src/mongo/s/catalog/type_collection.cpp
+++ b/src/mongo/s/catalog/type_collection.cpp
@@ -54,7 +54,7 @@ CollectionType::CollectionType(NamespaceString nss,
                          std::move(creationTime),
                          std::move(uuid),
                          std::move(keyPattern)) {
-    invariant(getTimestamp() != Timestamp(0, 0));
+    invariant(creationTime != Timestamp(0, 0));
     setEpoch(std::move(epoch));
 }
 
diff --git a/src/mongo/s/catalog_cache.cpp b/src/mongo/s/catalog_cache.cpp
index fff547935bc..60314d67ef3 100644
--- a/src/mongo/s/catalog_cache.cpp
+++ b/src/mongo/s/catalog_cache.cpp
@@ -37,8 +37,6 @@
 
 #include "mongo/s/catalog_cache.h"
 
-#include <fmt/format.h>
-
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/query/collation/collator_factory_interface.h"
 #include "mongo/db/repl/optime_with.h"
@@ -59,7 +57,6 @@ namespace mongo {
 namespace {
 
 MONGO_FAIL_POINT_DEFINE(blockCollectionCacheLookup);
-MONGO_FAIL_POINT_DEFINE(blockDatabaseCacheLookup);
 
 // How many times to try refreshing the routing info if the set of chunks loaded from the config
 // server is found to be inconsistent.
@@ -71,6 +68,9 @@ const int kCollectionCacheSize = 10000;
 const OperationContext::Decoration<bool> operationShouldBlockBehindCatalogCacheRefresh =
     OperationContext::declareDecoration<bool>();
 
+const OperationContext::Decoration<bool> operationBlockedBehindCatalogCacheRefresh =
+    OperationContext::declareDecoration<bool>();
+
 std::shared_ptr<RoutingTableHistory> createUpdatedRoutingTableHistory(
     OperationContext* opCtx,
     const NamespaceString& nss,
@@ -81,31 +81,28 @@ std::shared_ptr<RoutingTableHistory> createUpdatedRoutingTableHistory(
     if (isIncremental && collectionAndChunks.changedChunks.size() == 1 &&
         collectionAndChunks.changedChunks[0].getVersion() == existingHistory->optRt->getVersion()) {
 
-        tassert(7032310,
-                fmt::format("allowMigrations field of collection '{}' changed without changing the "
-                            "collection version {}. Old value: {}, new value: {}",
-                            nss.toString(),
-                            existingHistory->optRt->getVersion().toString(),
-                            existingHistory->optRt->allowMigrations(),
-                            collectionAndChunks.allowMigrations),
-                collectionAndChunks.allowMigrations == existingHistory->optRt->allowMigrations());
+        invariant(collectionAndChunks.allowMigrations == existingHistory->optRt->allowMigrations(),
+                  str::stream() << "allowMigrations field of " << nss
+                                << " collection changed without changing the collection version "
+                                << existingHistory->optRt->getVersion().toString()
+                                << ". Old value: " << existingHistory->optRt->allowMigrations()
+                                << ", new value: " << collectionAndChunks.allowMigrations);
 
         const auto& oldReshardingFields = existingHistory->optRt->getReshardingFields();
         const auto& newReshardingFields = collectionAndChunks.reshardingFields;
-        tassert(7032311,
-                fmt::format("reshardingFields field of collection '{}' changed without changing "
-                            "the collection version {}. Old value: {}, new value: {}",
-                            nss.toString(),
-                            existingHistory->optRt->getVersion().toString(),
-                            oldReshardingFields->toBSON().toString(),
-                            newReshardingFields->toBSON().toString()),
-                [&] {
-                    if (oldReshardingFields && newReshardingFields)
-                        return oldReshardingFields->toBSON().woCompare(
-                                   newReshardingFields->toBSON()) == 0;
-                    else
-                        return !oldReshardingFields && !newReshardingFields;
-                }());
+        invariant(
+            [&] {
+                if (oldReshardingFields && newReshardingFields)
+                    return oldReshardingFields->toBSON().woCompare(newReshardingFields->toBSON()) ==
+                        0;
+                else
+                    return !oldReshardingFields && !newReshardingFields;
+            }(),
+            str::stream() << "reshardingFields field of " << nss
+                          << " collection changed without changing the collection version "
+                          << existingHistory->optRt->getVersion().toString()
+                          << ". Old value: " << oldReshardingFields->toBSON()
+                          << ", new value: " << newReshardingFields->toBSON());
 
         return existingHistory->optRt;
     }
@@ -117,11 +114,7 @@ std::shared_ptr<RoutingTableHistory> createUpdatedRoutingTableHistory(
             return 0;
         }
         if (collectionAndChunks.maxChunkSizeBytes) {
-            tassert(7032312,
-                    fmt::format("Invalid maxChunkSizeBytes value {} for collection '{}'",
-                                nss.toString(),
-                                collectionAndChunks.maxChunkSizeBytes.get()),
-                    collectionAndChunks.maxChunkSizeBytes.get() > 0);
+            invariant(collectionAndChunks.maxChunkSizeBytes.get() > 0);
             return uint64_t(*collectionAndChunks.maxChunkSizeBytes);
         }
         return boost::none;
@@ -249,51 +242,26 @@ CatalogCache::CatalogCache(ServiceContext* const service, CatalogCacheLoader& ca
 }
 
 CatalogCache::~CatalogCache() {
-    // The executor is used by all the caches that correspond to the router role, so it must be
-    // joined before these caches are destroyed, per the contract of ReadThroughCache.
-    shutDownAndJoin();
-}
-
-void CatalogCache::shutDownAndJoin() {
+    // The executor is used by the Database and Collection caches,
+    // so it must be joined, before these caches are destroyed,
+    // per the contract of ReadThroughCache.
     _executor->shutdown();
     _executor->join();
 }
 
 StatusWith<CachedDatabaseInfo> CatalogCache::getDatabase(OperationContext* opCtx,
-                                                         StringData dbName) {
-    return _getDatabase(opCtx, dbName);
-}
-
-StatusWith<CachedDatabaseInfo> CatalogCache::_getDatabase(OperationContext* opCtx,
-                                                          StringData dbName,
-                                                          bool allowLocks) {
-    tassert(7032313,
+                                                         StringData dbName,
+                                                         bool allowLocks) {
+    if (!allowLocks) {
+        invariant(
+            !opCtx->lockState() || !opCtx->lockState()->isLocked(),
             "Do not hold a lock while refreshing the catalog cache. Doing so would potentially "
             "hold the lock during a network call, and can lead to a deadlock as described in "
-            "SERVER-37398.",
-            allowLocks || !opCtx->lockState() || !opCtx->lockState()->isLocked());
+            "SERVER-37398.");
+    }
 
     try {
-        auto dbEntryFuture =
-            _databaseCache.acquireAsync(dbName, CacheCausalConsistency::kLatestKnown);
-
-        if (allowLocks) {
-            // When allowLocks is true we may be holding a lock, so we don't want to block the
-            // current thread: if the future is ready let's use it, otherwise return an error.
-            if (dbEntryFuture.isReady()) {
-                return dbEntryFuture.get(opCtx);
-            } else {
-                // This error only contains the database name and must be handled by any callers of
-                // _getDatabase with the potential for allowLocks to be true. The caller should
-                // convert this to ErrorCodes::ShardCannotRefreshDueToLocksHeld with the full
-                // namespace.
-                return Status{ShardCannotRefreshDueToLocksHeldInfo(NamespaceString(dbName)),
-                              "Database info refresh did not complete"};
-            }
-        }
-
-        // From this point we can guarantee that allowLocks is false.
-        auto dbEntry = dbEntryFuture.get(opCtx);
+        auto dbEntry = _databaseCache.acquire(opCtx, dbName, CacheCausalConsistency::kLatestKnown);
         uassert(ErrorCodes::NamespaceNotFound,
                 str::stream() << "database " << dbName << " not found",
                 dbEntry);
@@ -309,28 +277,18 @@ StatusWith<ChunkManager> CatalogCache::_getCollectionRoutingInfoAt(
     const NamespaceString& nss,
     boost::optional<Timestamp> atClusterTime,
     bool allowLocks) {
-    tassert(7032314,
-            "Do not hold a lock while refreshing the catalog cache. Doing so would potentially "
-            "hold the lock during a network call, and can lead to a deadlock as described in "
-            "SERVER-37398.",
-            allowLocks || !opCtx->lockState() || !opCtx->lockState()->isLocked());
+    if (!allowLocks) {
+        invariant(!opCtx->lockState() || !opCtx->lockState()->isLocked(),
+                  "Do not hold a lock while refreshing the catalog cache. Doing so would "
+                  "potentially hold "
+                  "the lock during a network call, and can lead to a deadlock as described in "
+                  "SERVER-37398.");
+    }
 
     try {
-        const auto swDbInfo = _getDatabase(opCtx, nss.db(), allowLocks);
+        const auto swDbInfo = getDatabase(opCtx, nss.db(), allowLocks);
         if (!swDbInfo.isOK()) {
-            if (swDbInfo == ErrorCodes::ShardCannotRefreshDueToLocksHeld) {
-                // Since collection refreshes always imply database refreshes, it is ok to transform
-                // this error into a collection error rather than a database error.
-                auto dbRefreshInfo =
-                    swDbInfo.getStatus().extraInfo<ShardCannotRefreshDueToLocksHeldInfo>();
-                LOGV2_DEBUG(7850500,
-                            2,
-                            "Adding collection name to ShardCannotRefreshDueToLocksHeld error",
-                            "dbName"_attr = dbRefreshInfo->getNss().db(),
-                            "nss"_attr = nss);
-                return Status{ShardCannotRefreshDueToLocksHeldInfo(nss),
-                              "Routing info refresh did not complete"};
-            } else if (swDbInfo == ErrorCodes::NamespaceNotFound) {
+            if (swDbInfo == ErrorCodes::NamespaceNotFound) {
                 LOGV2_FOR_CATALOG_REFRESH(
                     4947103,
                     2,
@@ -368,6 +326,9 @@ StatusWith<ChunkManager> CatalogCache::_getCollectionRoutingInfoAt(
         }
 
         // From this point we can guarantee that allowLocks is false
+
+        operationBlockedBehindCatalogCacheRefresh(opCtx) = true;
+
         size_t acquireTries = 0;
         Timer t;
 
@@ -564,6 +525,37 @@ void CatalogCache::report(BSONObjBuilder* builder) const {
     _collectionCache.reportStats(&cacheStatsBuilder);
 }
 
+void CatalogCache::checkAndRecordOperationBlockedByRefresh(OperationContext* opCtx,
+                                                           mongo::LogicalOp opType) {
+    if (!isMongos() || !operationBlockedBehindCatalogCacheRefresh(opCtx)) {
+        return;
+    }
+
+    auto& opsBlockedByRefresh = _stats.operationsBlockedByRefresh;
+
+    opsBlockedByRefresh.countAllOperations.fetchAndAddRelaxed(1);
+
+    switch (opType) {
+        case LogicalOp::opInsert:
+            opsBlockedByRefresh.countInserts.fetchAndAddRelaxed(1);
+            break;
+        case LogicalOp::opQuery:
+            opsBlockedByRefresh.countQueries.fetchAndAddRelaxed(1);
+            break;
+        case LogicalOp::opUpdate:
+            opsBlockedByRefresh.countUpdates.fetchAndAddRelaxed(1);
+            break;
+        case LogicalOp::opDelete:
+            opsBlockedByRefresh.countDeletes.fetchAndAddRelaxed(1);
+            break;
+        case LogicalOp::opCommand:
+            opsBlockedByRefresh.countCommands.fetchAndAddRelaxed(1);
+            break;
+        default:
+            MONGO_UNREACHABLE;
+    }
+}
+
 void CatalogCache::invalidateDatabaseEntry_LINEARIZABLE(const StringData& dbName) {
     _databaseCache.invalidateKey(dbName);
 }
@@ -576,6 +568,26 @@ void CatalogCache::Stats::report(BSONObjBuilder* builder) const {
     builder->append("countStaleConfigErrors", countStaleConfigErrors.load());
 
     builder->append("totalRefreshWaitTimeMicros", totalRefreshWaitTimeMicros.load());
+
+    if (isMongos()) {
+        BSONObjBuilder operationsBlockedByRefreshBuilder(
+            builder->subobjStart("operationsBlockedByRefresh"));
+
+        operationsBlockedByRefreshBuilder.append(
+            "countAllOperations", operationsBlockedByRefresh.countAllOperations.load());
+        operationsBlockedByRefreshBuilder.append("countInserts",
+                                                 operationsBlockedByRefresh.countInserts.load());
+        operationsBlockedByRefreshBuilder.append("countQueries",
+                                                 operationsBlockedByRefresh.countQueries.load());
+        operationsBlockedByRefreshBuilder.append("countUpdates",
+                                                 operationsBlockedByRefresh.countUpdates.load());
+        operationsBlockedByRefreshBuilder.append("countDeletes",
+                                                 operationsBlockedByRefresh.countDeletes.load());
+        operationsBlockedByRefreshBuilder.append("countCommands",
+                                                 operationsBlockedByRefresh.countCommands.load());
+
+        operationsBlockedByRefreshBuilder.done();
+    }
 }
 
 CatalogCache::DatabaseCache::DatabaseCache(ServiceContext* service,
@@ -598,10 +610,6 @@ CatalogCache::DatabaseCache::LookupResult CatalogCache::DatabaseCache::_lookupDa
     const std::string& dbName,
     const DatabaseTypeValueHandle& previousDbType,
     const ComparableDatabaseVersion& previousDbVersion) {
-    if (MONGO_unlikely(blockDatabaseCacheLookup.shouldFail())) {
-        LOGV2(8023400, "Hanging before refreshing cached database entry");
-        blockDatabaseCacheLookup.pauseWhileSet();
-    }
     // TODO (SERVER-34164): Track and increment stats for database refreshes
 
     LOGV2_FOR_CATALOG_REFRESH(24102, 2, "Refreshing cached database entry", "db"_attr = dbName);
@@ -693,7 +701,7 @@ CatalogCache::CollectionCache::LookupResult CatalogCache::CollectionCache::_look
     OperationContext* opCtx,
     const NamespaceString& nss,
     const RoutingTableHistoryValueHandle& existingHistory,
-    const ComparableChunkVersion& timeInStore) {
+    const ComparableChunkVersion& previousVersion) {
     const bool isIncremental(existingHistory && existingHistory->optRt);
     _updateRefreshesStats(isIncremental, true);
     blockCollectionCacheLookup.pauseWhileSet(opCtx);
@@ -712,7 +720,7 @@ CatalogCache::CollectionCache::LookupResult CatalogCache::CollectionCache::_look
                                   "Refreshing cached collection",
                                   "namespace"_attr = nss,
                                   "lookupSinceVersion"_attr = lookupVersion,
-                                  "timeInStore"_attr = timeInStore);
+                                  "timeInStore"_attr = previousVersion);
 
         auto collectionAndChunks = _catalogCacheLoader.getChunksSince(nss, lookupVersion).get();
 
@@ -734,18 +742,14 @@ CatalogCache::CollectionCache::LookupResult CatalogCache::CollectionCache::_look
         const ChunkVersion newVersion = newRoutingHistory->getVersion();
         newComparableVersion.setChunkVersion(newVersion);
 
-        // The log below is logged at debug(0) (equivalent to info level) only if the new placement
-        // version is different than the one we already had (if any).
-        LOGV2_FOR_CATALOG_REFRESH(
-            4619901,
-            (!isIncremental || newVersion != existingHistory->optRt->getVersion()) ? 0 : 1,
-            "Refreshed cached collection",
-            "namespace"_attr = nss,
-            "lookupSinceVersion"_attr = lookupVersion,
-            "newVersion"_attr = newComparableVersion,
-            "timeInStore"_attr = timeInStore,
-            "duration"_attr = Milliseconds(t.millis()));
-
+        LOGV2_FOR_CATALOG_REFRESH(4619901,
+                                  isIncremental || newComparableVersion != previousVersion ? 0 : 1,
+                                  "Refreshed cached collection",
+                                  "namespace"_attr = nss,
+                                  "lookupSinceVersion"_attr = lookupVersion,
+                                  "newVersion"_attr = newComparableVersion,
+                                  "timeInStore"_attr = previousVersion,
+                                  "duration"_attr = Milliseconds(t.millis()));
         _updateRefreshesStats(isIncremental, false);
 
         return LookupResult(OptionalRoutingTableHistory(std::move(newRoutingHistory)),
diff --git a/src/mongo/s/catalog_cache.h b/src/mongo/s/catalog_cache.h
index 1b40ffb5a53..48c781d27ad 100644
--- a/src/mongo/s/catalog_cache.h
+++ b/src/mongo/s/catalog_cache.h
@@ -140,16 +140,13 @@ public:
     virtual ~CatalogCache();
 
     /**
-     * Shuts down and joins the executor used by all the caches to run their blocking work.
-     */
-    void shutDownAndJoin();
-
-    /**
      * Blocking method that ensures the specified database is in the cache, loading it if necessary,
      * and returns it. If the database was not in cache, all the sharded collections will be in the
      * 'needsRefresh' state.
      */
-    StatusWith<CachedDatabaseInfo> getDatabase(OperationContext* opCtx, StringData dbName);
+    StatusWith<CachedDatabaseInfo> getDatabase(OperationContext* opCtx,
+                                               StringData dbName,
+                                               bool allowLocks = false);
 
     /**
      * Blocking method to get the routing information for a specific collection at a given cluster
@@ -257,6 +254,13 @@ public:
     void report(BSONObjBuilder* builder) const;
 
     /**
+     * Checks if the current operation was ever marked as needing refresh. If the curent operation
+     * was marked as needing refresh, updates the relevant counters inside the Stats struct.
+     */
+    void checkAndRecordOperationBlockedByRefresh(OperationContext* opCtx, mongo::LogicalOp opType);
+
+
+    /**
      * Non-blocking method that marks the current database entry for the dbName as needing
      * refresh. Will cause all further targetting attempts to block on a catalog cache refresh,
      * even if they do not require causal consistency.
@@ -332,13 +336,6 @@ private:
         void _updateRefreshesStats(bool isIncremental, bool add);
     };
 
-    // Callers of this internal function that are passing allowLocks must handle allowLocks failures
-    // by checking for ErrorCodes::ShardCannotRefreshDueToLocksHeld and addint the full namespace to
-    // the exception.
-    StatusWith<CachedDatabaseInfo> _getDatabase(OperationContext* opCtx,
-                                                StringData dbName,
-                                                bool allowLocks = false);
-
     StatusWith<ChunkManager> _getCollectionRoutingInfoAt(OperationContext* opCtx,
                                                          const NamespaceString& nss,
                                                          boost::optional<Timestamp> atClusterTime,
@@ -366,6 +363,18 @@ private:
         // combined
         AtomicWord<long long> totalRefreshWaitTimeMicros{0};
 
+        // Cumulative, always-increasing counter of how many operations have been blocked by a
+        // catalog cache refresh. Broken down by operation type to match the operations tracked
+        // by the OpCounters class.
+        struct OperationsBlockedByRefresh {
+            AtomicWord<long long> countAllOperations{0};
+            AtomicWord<long long> countInserts{0};
+            AtomicWord<long long> countQueries{0};
+            AtomicWord<long long> countUpdates{0};
+            AtomicWord<long long> countDeletes{0};
+            AtomicWord<long long> countCommands{0};
+        } operationsBlockedByRefresh;
+
         /**
          * Reports the accumulated statistics for serverStatus.
          */
diff --git a/src/mongo/s/catalog_cache_loader.h b/src/mongo/s/catalog_cache_loader.h
index af2bdb4045b..18a26324fbc 100644
--- a/src/mongo/s/catalog_cache_loader.h
+++ b/src/mongo/s/catalog_cache_loader.h
@@ -126,11 +126,6 @@ public:
     virtual void onStepUp() = 0;
 
     /**
-     * Interrupts ongoing refreshes on rollback.
-     */
-    virtual void onReplicationRollback() = 0;
-
-    /**
      * Transitions into shut down and cleans up state. Once this transitions to shut down, should
      * not be able to transition back to normal. Should be safe to be called more than once.
      */
diff --git a/src/mongo/s/catalog_cache_loader_mock.cpp b/src/mongo/s/catalog_cache_loader_mock.cpp
index ffca2e3786e..09b3b60e3f4 100644
--- a/src/mongo/s/catalog_cache_loader_mock.cpp
+++ b/src/mongo/s/catalog_cache_loader_mock.cpp
@@ -61,10 +61,6 @@ void CatalogCacheLoaderMock::onStepUp() {
     MONGO_UNREACHABLE;
 }
 
-void CatalogCacheLoaderMock::onReplicationRollback() {
-    MONGO_UNREACHABLE;
-}
-
 void CatalogCacheLoaderMock::shutDown() {}
 
 void CatalogCacheLoaderMock::notifyOfCollectionVersionUpdate(const NamespaceString& nss) {
diff --git a/src/mongo/s/catalog_cache_loader_mock.h b/src/mongo/s/catalog_cache_loader_mock.h
index dd015b0258d..13538c4f69c 100644
--- a/src/mongo/s/catalog_cache_loader_mock.h
+++ b/src/mongo/s/catalog_cache_loader_mock.h
@@ -52,7 +52,6 @@ public:
     void initializeReplicaSetRole(bool isPrimary) override;
     void onStepDown() override;
     void onStepUp() override;
-    void onReplicationRollback() override;
     void shutDown() override;
     void notifyOfCollectionVersionUpdate(const NamespaceString& nss) override;
     void waitForCollectionFlush(OperationContext* opCtx, const NamespaceString& nss) override;
diff --git a/src/mongo/s/catalog_cache_refresh_test.cpp b/src/mongo/s/catalog_cache_refresh_test.cpp
index 39c8e4b13cd..c958dec98fb 100644
--- a/src/mongo/s/catalog_cache_refresh_test.cpp
+++ b/src/mongo/s/catalog_cache_refresh_test.cpp
@@ -33,7 +33,6 @@
 
 #include "mongo/db/concurrency/locker_noop.h"
 #include "mongo/db/pipeline/aggregation_request_helper.h"
-#include "mongo/db/query/cursor_response.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/catalog/type_collection.h"
 #include "mongo/s/catalog/type_database_gen.h"
diff --git a/src/mongo/s/catalog_cache_test.cpp b/src/mongo/s/catalog_cache_test.cpp
index 61a6ca2b067..be608cbb68c 100644
--- a/src/mongo/s/catalog_cache_test.cpp
+++ b/src/mongo/s/catalog_cache_test.cpp
@@ -33,12 +33,9 @@
 
 #include <boost/optional/optional_io.hpp>
 
-#include "mongo/db/cursor_id.h"
-#include "mongo/db/query/cursor_response.h"
 #include "mongo/s/catalog/type_database_gen.h"
 #include "mongo/s/catalog_cache.h"
 #include "mongo/s/catalog_cache_loader_mock.h"
-#include "mongo/s/shard_cannot_refresh_due_to_locks_held_exception.h"
 #include "mongo/s/sharding_router_test_fixture.h"
 #include "mongo/s/stale_exception.h"
 #include "mongo/s/type_collection_common_types_gen.h"
@@ -302,69 +299,6 @@ TEST_F(CatalogCacheTest, OnStaleShardVersionWithGraterVersion) {
     ASSERT(status == ErrorCodes::InternalError);
 }
 
-TEST_F(CatalogCacheTest, GetCollectionRoutingInfoAllowLocksReturnsImmediately) {
-    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp(1, 1));
-    const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), Timestamp(1, 1));
-
-    loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], dbVersion)});
-    loadCollection(cachedCollVersion);
-
-    const auto swCm =
-        _catalogCache->getCollectionRoutingInfo(operationContext(), kNss, true /* allowLocks */);
-    ASSERT_OK(swCm.getStatus());
-
-    ASSERT(swCm.getValue().getVersion() == cachedCollVersion);
-}
-
-TEST_F(CatalogCacheTest, GetCollectionRoutingInfoAllowLocksNeedsToFetchNewCollInfo) {
-    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp(1, 1));
-    const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), Timestamp(1, 1));
-    const auto wantedCollVersion =
-        ChunkVersion(2, 0, cachedCollVersion.epoch(), cachedCollVersion.getTimestamp());
-
-    loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], dbVersion)});
-    loadCollection(cachedCollVersion);
-    _catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
-        kNss, wantedCollVersion, kShards[0]);
-
-    {
-        FailPointEnableBlock failPoint("blockCollectionCacheLookup");
-
-        const auto status =
-            _catalogCache->getCollectionRoutingInfo(operationContext(), kNss, true /* allowLocks */)
-                .getStatus();
-
-        ASSERT(status == ErrorCodes::ShardCannotRefreshDueToLocksHeld);
-        auto refreshInfo = status.extraInfo<ShardCannotRefreshDueToLocksHeldInfo>();
-        ASSERT(refreshInfo);
-    }
-    // Cancel ongoing refresh
-    _catalogCache->invalidateCollectionEntry_LINEARIZABLE(kNss);
-}
-
-TEST_F(CatalogCacheTest, GetCollectionRoutingInfoAllowLocksNeedsToFetchNewDBInfo) {
-    const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp(1, 1));
-    const auto cachedCollVersion = ChunkVersion(1, 0, OID::gen(), Timestamp(1, 1));
-
-    loadDatabases({DatabaseType(kNss.db().toString(), kShards[0], dbVersion)});
-    loadCollection(cachedCollVersion);
-    _catalogCache->invalidateDatabaseEntry_LINEARIZABLE(kNss.db());
-
-    {
-        FailPointEnableBlock failPoint("blockDatabaseCacheLookup");
-
-        const auto status =
-            _catalogCache->getCollectionRoutingInfo(operationContext(), kNss, true /* allowLocks */)
-                .getStatus();
-
-        ASSERT(status == ErrorCodes::ShardCannotRefreshDueToLocksHeld);
-        auto refreshInfo = status.extraInfo<ShardCannotRefreshDueToLocksHeldInfo>();
-        ASSERT(refreshInfo);
-    }
-    // Cancel ongoing refresh
-    _catalogCache->invalidateDatabaseEntry_LINEARIZABLE(kNss.db());
-}
-
 TEST_F(CatalogCacheTest, TimeseriesFieldsAreProperlyPropagatedOnCC) {
     const auto dbVersion = DatabaseVersion(UUID::gen(), Timestamp(1, 1));
     const auto epoch = OID::gen();
diff --git a/src/mongo/s/catalog_cache_test_fixture.cpp b/src/mongo/s/catalog_cache_test_fixture.cpp
index 9edd553f704..6e66a30d6b2 100644
--- a/src/mongo/s/catalog_cache_test_fixture.cpp
+++ b/src/mongo/s/catalog_cache_test_fixture.cpp
@@ -38,9 +38,7 @@
 #include "mongo/client/remote_command_targeter_factory_mock.h"
 #include "mongo/client/remote_command_targeter_mock.h"
 #include "mongo/db/client.h"
-#include "mongo/db/cursor_id.h"
 #include "mongo/db/query/collation/collator_factory_mock.h"
-#include "mongo/db/query/cursor_response.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/catalog/type_collection.h"
 #include "mongo/s/catalog/type_database_gen.h"
diff --git a/src/mongo/s/chunk.cpp b/src/mongo/s/chunk.cpp
index e141cfea226..e59c9143ecf 100644
--- a/src/mongo/s/chunk.cpp
+++ b/src/mongo/s/chunk.cpp
@@ -107,32 +107,16 @@ void ChunkInfo::throwIfMovedSince(const Timestamp& ts) const {
 }
 
 bool ChunkInfo::containsKey(const BSONObj& shardKey) const {
-    return _range.containsKey(shardKey);
+    return getMin().woCompare(shardKey) <= 0 && shardKey.woCompare(getMax()) < 0;
 }
 
 std::string ChunkInfo::toString() const {
-    return toBSON().toString();
-}
-
-BSONObj ChunkInfo::toBSON() const {
-    BSONObjBuilder bob;
-    _range.append(&bob);
-    bob.append("maxKeyString", _maxKeyString);
-    bob.append("shardId", _shardId);
-    _lastmod.serializeToBSON("lastmod", &bob);
-    bob.append("jumbo", _jumbo.load());
-    bob.append("bytesWritten", (long long)_writesTracker->getBytesWritten());
-
-    BSONArrayBuilder historyArr{bob.subarrayStart("history")};
-    for (const auto& historyEntry : _history) {
-        historyArr.append(historyEntry.toBSON());
-    }
-    historyArr.doneFast();
-    return bob.obj();
+    return str::stream() << ChunkType::shard() << ": " << _shardId << ", " << ChunkType::lastmod()
+                         << ": " << _lastmod.toString() << ", " << _range.toString();
 }
 
 void ChunkInfo::markAsJumbo() {
-    _jumbo.store(true);
+    _jumbo = true;
 }
 
 void Chunk::throwIfMoved() const {
@@ -143,16 +127,4 @@ void Chunk::throwIfMoved() const {
     _chunkInfo.throwIfMovedSince(*_atClusterTime);
 }
 
-std::string Chunk::toString() const {
-    return toBSON().toString();
-}
-
-BSONObj Chunk::toBSON() const {
-    BSONObjBuilder bob;
-    bob.append("chunkInfo", _chunkInfo.toBSON());
-    bob.append("atClusterTime", _atClusterTime ? _atClusterTime->toBSON() : BSONObj());
-    return bob.obj();
-}
-
-
 }  // namespace mongo
diff --git a/src/mongo/s/chunk.h b/src/mongo/s/chunk.h
index 16f5909a72a..3f60e997737 100644
--- a/src/mongo/s/chunk.h
+++ b/src/mongo/s/chunk.h
@@ -29,7 +29,6 @@
 
 #pragma once
 
-#include "mongo/platform/atomic_word.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/chunk_version.h"
 #include "mongo/s/shard_id.h"
@@ -93,7 +92,7 @@ public:
     }
 
     bool isJumbo() const {
-        return _jumbo.load();
+        return _jumbo;
     }
 
     /**
@@ -108,8 +107,6 @@ public:
      */
     std::string toString() const;
 
-    BSONObj toBSON() const;
-
     // Returns true if this chunk contains the given shard key, and false otherwise
     //
     // Note: this function takes an extracted *key*, not an original document (the point may be
@@ -133,7 +130,7 @@ private:
 
     // Indicates whether this chunk should be treated as jumbo and not attempted to be moved or
     // split
-    AtomicWord<bool> _jumbo;
+    mutable bool _jumbo;
 
     // Used for tracking writes to this chunk, to estimate its size for the autosplitter. Since
     // ChunkInfo objects are always treated as const, and this contains metadata about the chunk
@@ -192,8 +189,9 @@ public:
     /**
      * Returns a string represenation of the chunk for logging.
      */
-    std::string toString() const;
-    BSONObj toBSON() const;
+    std::string toString() const {
+        return _chunkInfo.toString();
+    }
 
     // Returns true if this chunk contains the given shard key, and false otherwise
     //
diff --git a/src/mongo/s/chunk_manager.cpp b/src/mongo/s/chunk_manager.cpp
index 1d3ed85e925..888ba644b52 100644
--- a/src/mongo/s/chunk_manager.cpp
+++ b/src/mongo/s/chunk_manager.cpp
@@ -33,8 +33,6 @@
 
 #include "mongo/s/chunk_manager.h"
 
-#include <algorithm>
-
 #include "mongo/bson/simple_bsonobj_comparator.h"
 #include "mongo/db/matcher/extensions_callback_noop.h"
 #include "mongo/db/query/collation/collation_index_key.h"
@@ -65,42 +63,18 @@ void checkAllElementsAreOfType(BSONType type, const BSONObj& o) {
             allElementsAreOfType(type, o));
 }
 
-bool overlaps(const ChunkInfo& a, const ChunkInfo& b) {
-    // Microbenchmarks results showed that comparing keystrings
-    // is more performant than comparing BSONObj
-    const auto aMinKeyStr = ShardKeyPattern::toKeyString(a.getMin());
-    const auto& aMaxKeyStr = a.getMaxKeyString();
-    const auto bMinKeyStr = ShardKeyPattern::toKeyString(b.getMin());
-    const auto& bMaxKeyStr = b.getMaxKeyString();
-
-    return aMinKeyStr < bMaxKeyStr && aMaxKeyStr > bMinKeyStr;
-}
-
-void checkChunksAreContiguous(const ChunkInfo& left, const ChunkInfo& right) {
-    const auto& leftKeyString = left.getMaxKeyString();
-    const auto rightKeyString = ShardKeyPattern::toKeyString(right.getMin());
-    if (leftKeyString == rightKeyString) {
-        return;
-    }
-
-    if (SimpleBSONObjComparator::kInstance.evaluate(left.getMax() < right.getMin())) {
-        uasserted(ErrorCodes::ConflictingOperationInProgress,
-                  str::stream() << "Gap exists in the routing table between chunks "
-                                << left.getRange().toString() << " and "
-                                << right.getRange().toString());
+void appendChunkTo(std::vector<std::shared_ptr<ChunkInfo>>& chunks,
+                   const std::shared_ptr<ChunkInfo>& chunk) {
+    if (!chunks.empty() && chunk->getRange().overlaps(chunks.back()->getRange())) {
+        if (chunks.back()->getLastmod().isOlderThan(chunk->getLastmod())) {
+            chunks.pop_back();
+            chunks.push_back(chunk);
+        }
     } else {
-        uasserted(ErrorCodes::ConflictingOperationInProgress,
-                  str::stream() << "Overlap exists in the routing table between chunks "
-                                << left.getRange().toString() << " and "
-                                << right.getRange().toString());
+        chunks.push_back(chunk);
     }
-
-    MONGO_UNREACHABLE;
 }
 
-using ChunkVector = ChunkMap::ChunkVector;
-using ChunkVectorMap = ChunkMap::ChunkVectorMap;
-
 // This function processes the passed in chunks by removing the older versions of any overlapping
 // chunks. The resulting chunks must be ordered by the maximum bound and not have any
 // overlapping chunks. In order to process the original set of chunks correctly which may have
@@ -125,18 +99,10 @@ std::vector<std::shared_ptr<ChunkInfo>> flatten(const std::vector<ChunkType>& ch
 
     std::vector<std::shared_ptr<ChunkInfo>> flattened;
     flattened.reserve(changedChunkInfos.size());
-    flattened.emplace_back(std::move(changedChunkInfos[0]));
+    flattened.push_back(changedChunkInfos[0]);
 
     for (size_t i = 1; i < changedChunkInfos.size(); ++i) {
-        auto& chunk = changedChunkInfos[i];
-        if (overlaps(*chunk, *flattened.back())) {
-            if (flattened.back()->getLastmod().isOlderThan(chunk->getLastmod())) {
-                flattened.pop_back();
-                flattened.emplace_back(std::move(chunk));
-            }
-        } else {
-            flattened.emplace_back(std::move(chunk));
-        }
+        appendChunkTo(flattened, changedChunkInfos[i]);
     }
 
     std::reverse(flattened.begin(), flattened.end());
@@ -144,489 +110,205 @@ std::vector<std::shared_ptr<ChunkInfo>> flatten(const std::vector<ChunkType>& ch
     return flattened;
 }
 
-}  // namespace
-
-size_t ChunkMap::size() const {
-    size_t totalChunks{0};
-    for (const auto& mapIt : _chunkVectorMap) {
-        totalChunks += mapIt.second->size();
-    }
-    return totalChunks;
-}
-
-std::shared_ptr<ChunkInfo> ChunkMap::findIntersectingChunk(const BSONObj& shardKey) const {
-    const auto shardKeyString = ShardKeyPattern::toKeyString(shardKey);
-
-    const auto it = _chunkVectorMap.upper_bound(shardKeyString);
-    if (it == _chunkVectorMap.end()) {
-        // upper_bound() will miss the last chunkVector if shardKey is actually the MaxKey,
-        // thus we need to check explicitly if shardKey is contained in the last chunk.
-        if (const auto& lastChunk = std::prev(_chunkVectorMap.end())->second->back();
-            lastChunk->containsKey(shardKey)) {
-            return lastChunk;
-        } else {
-            return {};
-        }
-    }
-
-    const auto& chunkVector = *(it->second);
-    const auto chunkIt = _findIntersectingChunkIterator(
-        shardKeyString, chunkVector.begin(), chunkVector.end(), true /*isMaxInclusive*/);
-
-    if (chunkIt == chunkVector.end()) {
-        return {};
-    }
+void validateChunkIsNotOlderThan(const std::shared_ptr<ChunkInfo>& chunk,
+                                 const ChunkVersion& version) {
+    uassert(ErrorCodes::ConflictingOperationInProgress,
+            str::stream() << "Changed chunk " << chunk->toString()
+                          << " has timestamp different from that of the collection "
+                          << version.getTimestamp(),
+            version.getTimestamp() == chunk->getLastmod().getTimestamp());
 
-    return *chunkIt;
+    uassert(626840,
+            str::stream()
+                << "Changed chunk " << chunk->toString()
+                << " doesn't have version that's greater or equal than that of the collection "
+                << version.toString(),
+            version.isOlderOrEqualThan(chunk->getLastmod()));
 }
 
-ChunkMap ChunkMap::createMerged(std::vector<std::shared_ptr<ChunkInfo>> changedChunks) const {
-    auto updatedChunkMap = _makeUpdated(std::move(changedChunks));
-    tassert(6752900,
-            "Chunk map found to be empty after refresh",
-            updatedChunkMap._chunkVectorMap.size() &&
-                updatedChunkMap._chunkVectorMap.begin()->second->size());
-    return updatedChunkMap;
-}
-
-void ChunkMap::_commitUpdatedChunkVector(std::shared_ptr<ChunkVector>&& chunkVectorPtr,
-                                         bool checkMaxKeyConsistency) {
-
-    invariant(!chunkVectorPtr->empty());
-
-    const auto& vectorMaxKeyString = chunkVectorPtr->back()->getMaxKeyString();
-    const auto nextMapIt = _chunkVectorMap.lower_bound(vectorMaxKeyString);
+}  // namespace
 
-    // Check lower bound is consistent
-    if (nextMapIt == _chunkVectorMap.begin()) {
-        checkAllElementsAreOfType(MinKey, chunkVectorPtr->front()->getMin());
-    } else {
-        checkChunksAreContiguous(*(std::prev(nextMapIt)->second->back()),
-                                 *(chunkVectorPtr->front()));
-    }
+ShardVersionMap ChunkMap::constructShardVersionMap() const {
+    ShardVersionMap shardVersions;
+    ChunkVector::const_iterator current = _chunkMap.cbegin();
+
+    boost::optional<BSONObj> firstMin = boost::none;
+    boost::optional<BSONObj> lastMax = boost::none;
+
+    while (current != _chunkMap.cend()) {
+        const auto& firstChunkInRange = *current;
+        const auto& currentRangeShardId = firstChunkInRange->getShardIdAt(boost::none);
+
+        // Tracks the max shard version for the shard on which the current range will reside
+        auto shardVersionIt = shardVersions.find(currentRangeShardId);
+        if (shardVersionIt == shardVersions.end()) {
+            shardVersionIt = shardVersions
+                                 .emplace(std::piecewise_construct,
+                                          std::forward_as_tuple(currentRangeShardId),
+                                          std::forward_as_tuple(_collectionVersion.epoch(),
+                                                                _collectionVersion.getTimestamp()))
+                                 .first;
+        }
 
-    if (checkMaxKeyConsistency) {
-        // Check upper bound is consistent
-        if (nextMapIt == _chunkVectorMap.end()) {
-            checkAllElementsAreOfType(MaxKey, chunkVectorPtr->back()->getMax());
-        } else {
-            checkChunksAreContiguous(*(chunkVectorPtr->back()), *(nextMapIt->second->front()));
+        auto& maxShardVersion = shardVersionIt->second.shardVersion;
+
+        current =
+            std::find_if(current,
+                         _chunkMap.cend(),
+                         [&currentRangeShardId, &maxShardVersion](const auto& currentChunk) {
+                             if (currentChunk->getShardIdAt(boost::none) != currentRangeShardId)
+                                 return true;
+
+                             if (maxShardVersion.isOlderThan(currentChunk->getLastmod()))
+                                 maxShardVersion = currentChunk->getLastmod();
+
+                             return false;
+                         });
+
+        const auto rangeLast = *std::prev(current);
+
+        const auto& rangeMin = firstChunkInRange->getMin();
+        const auto& rangeMax = rangeLast->getMax();
+
+        // Check the continuity of the chunks map
+        if (lastMax && !SimpleBSONObjComparator::kInstance.evaluate(*lastMax == rangeMin)) {
+            if (SimpleBSONObjComparator::kInstance.evaluate(*lastMax < rangeMin))
+                uasserted(ErrorCodes::ConflictingOperationInProgress,
+                          str::stream() << "Gap exists in the routing table between chunks "
+                                        << findIntersectingChunk(*lastMax)->getRange().toString()
+                                        << " and " << rangeLast->getRange().toString());
+            else
+                uasserted(ErrorCodes::ConflictingOperationInProgress,
+                          str::stream() << "Overlap exists in the routing table between chunks "
+                                        << findIntersectingChunk(*lastMax)->getRange().toString()
+                                        << " and " << rangeLast->getRange().toString());
         }
-    }
 
-    auto minVectorSize = _maxChunkVectorSize / 2;
-    if (chunkVectorPtr->size() < minVectorSize) {
-        _mergeAndCommitUpdatedChunkVector(nextMapIt, std::move(chunkVectorPtr));
-    } else {
-        _splitAndCommitUpdatedChunkVector(nextMapIt, std::move(chunkVectorPtr));
-    }
-}
+        if (!firstMin)
+            firstMin = rangeMin;
 
-void ChunkMap::_mergeAndCommitUpdatedChunkVector(ChunkVectorMap::const_iterator pos,
-                                                 std::shared_ptr<ChunkVector>&& smallVectorPtr) {
-    if (pos == _chunkVectorMap.begin()) {
-        // Vector will be placed at the head of the map,
-        // thus there is not previous vector we could merge with
-        smallVectorPtr->shrink_to_fit();
-        _chunkVectorMap.emplace_hint(
-            pos, smallVectorPtr->back()->getMaxKeyString(), std::move(smallVectorPtr));
+        lastMax = rangeMax;
 
-        return;
+        // If a shard has chunks it must have a shard version, otherwise we have an invalid chunk
+        // somewhere, which should have been caught at chunk load time
+        invariant(maxShardVersion.isSet());
     }
 
-    auto prevVectorPtr = _chunkVectorMap.extract(std::prev(pos)).mapped();
-    auto mergeVectorPtr = std::make_shared<ChunkVector>();
-    mergeVectorPtr->reserve(prevVectorPtr->size() + smallVectorPtr->size());
-
-    // Fill initial part of merged vector with a copy of old vector (prevVectorPtr)
-    // Note that the old vector is potentially shared with previous ChunkMap instances,
-    // thus we copy rather than moving elements to maintain its integrity.
-    mergeVectorPtr->insert(mergeVectorPtr->end(), prevVectorPtr->begin(), prevVectorPtr->end());
-
-    // Fill the rest of merged vector with the small updated vector
-    mergeVectorPtr->insert(mergeVectorPtr->end(),
-                           std::make_move_iterator(smallVectorPtr->begin()),
-                           std::make_move_iterator(smallVectorPtr->end()));
+    if (!_chunkMap.empty()) {
+        invariant(!shardVersions.empty());
+        invariant(firstMin.is_initialized());
+        invariant(lastMax.is_initialized());
 
-    _chunkVectorMap.emplace_hint(
-        pos, mergeVectorPtr->back()->getMaxKeyString(), std::move(mergeVectorPtr));
-}
-
-/*
- * Split the given chunk vector into pieces not bigger than _maxChunkVectorSize
- * and add them to the chunkVector map.
- *
- * When chunks can't be divided equally among all generated pieces,
- * this algorithm guarantee that the size difference between all pieces will be minimal and that
- * smaller pieces will be placed at the end.
- */
-void ChunkMap::_splitAndCommitUpdatedChunkVector(ChunkVectorMap::const_iterator pos,
-                                                 std::shared_ptr<ChunkVector>&& chunkVectorPtr) {
-    auto& chunkVector = *chunkVectorPtr;
-    const long long totalSize = chunkVector.size();
-    const long long numPieces = (totalSize + _maxChunkVectorSize - 1) / _maxChunkVectorSize;
-    const long long largePieceSize = (totalSize + numPieces - 1) / numPieces;
-    const long long numLargePieces = totalSize % numPieces;
-    const long long smallPieceSize = totalSize / numPieces;
-
-    auto lastPos = pos;
-    auto chunkIt = chunkVector.end();
-    for (int pieceCount = 1; pieceCount < numPieces; pieceCount++) {
-        auto tmpVectorPtr = std::make_shared<ChunkVector>();
-        auto targetPieceSize =
-            (numPieces - pieceCount) < numLargePieces ? largePieceSize : smallPieceSize;
-        tmpVectorPtr->insert(tmpVectorPtr->end(),
-                             std::make_move_iterator(chunkIt - targetPieceSize),
-                             std::make_move_iterator(chunkIt));
-        chunkIt -= targetPieceSize;
-        lastPos = _chunkVectorMap.emplace_hint(
-            lastPos, tmpVectorPtr->back()->getMaxKeyString(), std::move(tmpVectorPtr));
+        checkAllElementsAreOfType(MinKey, firstMin.get());
+        checkAllElementsAreOfType(MaxKey, lastMax.get());
     }
 
-    invariant(std::distance(chunkVector.begin(), chunkIt) == largePieceSize);
-    chunkVector.resize(largePieceSize);
-    chunkVector.shrink_to_fit();
-    _chunkVectorMap.emplace_hint(
-        lastPos, chunkVector.back()->getMaxKeyString(), std::move(chunkVectorPtr));
+    return shardVersions;
 }
 
-void ChunkMap::_updateShardVersionFromDiscardedChunk(const ChunkInfo& chunk) {
-    auto shardVersionIt = _shardVersions.find(chunk.getShardId());
-    if (shardVersionIt != _shardVersions.end() &&
-        shardVersionIt->second.shardVersion == chunk.getLastmod()) {
-        _shardVersions.erase(shardVersionIt);
+void ChunkMap::appendChunk(const std::shared_ptr<ChunkInfo>& chunk) {
+    appendChunkTo(_chunkMap, chunk);
+    const auto chunkVersion = chunk->getLastmod();
+    if (_collectionVersion.isOlderThan(chunkVersion)) {
+        _collectionVersion = ChunkVersion(chunkVersion.majorVersion(),
+                                          chunkVersion.minorVersion(),
+                                          chunkVersion.epoch(),
+                                          _collTimestamp);
     }
 }
 
-void ChunkMap::_updateShardVersionFromUpdateChunk(const ChunkInfo& chunk,
-                                                  const ShardVersionMap& oldShardVersions) {
-    const auto& newVersion = chunk.getLastmod();
-    const auto newValidAfter = [&] {
-        auto thisChunkValidAfter = chunk.getHistory().empty()
-            ? Timestamp{0, 0}
-            : chunk.getHistory().front().getValidAfter();
-
-        auto oldShardVersionIt = oldShardVersions.find(chunk.getShardId());
-        auto oldShardValidAfter = oldShardVersionIt == oldShardVersions.end()
-            ? Timestamp{0, 0}
-            : oldShardVersionIt->second.validAfter;
-
-        return std::max(thisChunkValidAfter, oldShardValidAfter);
-    }();
-
-    // Version for this chunk shard got updated
-    bool versionUpdated{false};
-
-    auto [shardVersionIt, created] =
-        _shardVersions.try_emplace(chunk.getShardId(), newVersion, newValidAfter);
-
-    if (created) {
-        // We just created a new entry in the _shardVersions map with latest version and latest
-        // valid after.
-        versionUpdated = true;
-    } else {
-        // _shardVersions map already contained an entry for this chunk shard
-
-        // Update version for this shard
-        if (shardVersionIt->second.shardVersion.isOlderThan(newVersion)) {
-            shardVersionIt->second.shardVersion = newVersion;
-            versionUpdated = true;
-        }
+std::shared_ptr<ChunkInfo> ChunkMap::findIntersectingChunk(const BSONObj& shardKey) const {
+    const auto it = _findIntersectingChunk(shardKey);
 
-        // Update validAfter for this shard
-        if (newValidAfter > shardVersionIt->second.validAfter) {
-            shardVersionIt->second.validAfter = newValidAfter;
-        }
-    }
+    if (it != _chunkMap.end())
+        return *it;
 
-    // Update version for the entire collection
-    if (versionUpdated && _collectionVersion.isOlderThan(newVersion)) {
-        _collectionVersion = ChunkVersion{newVersion.majorVersion(),
-                                          newVersion.minorVersion(),
-                                          newVersion.epoch(),
-                                          _collectionVersion.getTimestamp()};
-    }
+    return std::shared_ptr<ChunkInfo>();
 }
 
-ChunkMap ChunkMap::_makeUpdated(ChunkVector&& updateChunks) const {
-    ChunkMap newMap{*this};
+ChunkMap ChunkMap::createMerged(
+    const std::vector<std::shared_ptr<ChunkInfo>>& changedChunks) const {
+    size_t chunkMapIndex = 0;
+    size_t changedChunkIndex = 0;
 
-    if (updateChunks.empty()) {
-        // No updates, just clone the original map
-        return newMap;
-    }
+    ChunkMap updatedChunkMap(
+        getVersion().epoch(), getVersion().getTimestamp(), _chunkMap.size() + changedChunks.size());
 
-    std::shared_ptr<ChunkVector> oldVectorPtr;
-    ChunkVector::const_iterator oldChunkIt;
-    ChunkVector::iterator updateChunkIt;
-    ChunkVector::const_iterator updateChunkWrittenBytesIt;
-    std::shared_ptr<ChunkVector> newVectorPtr;
-    bool lastCommittedIsNew;
-
-    const auto processOldChunk = [&](const std::shared_ptr<ChunkInfo>& nextChunkPtr,
-                                     bool discard = false) {
-        if (discard) {
-            // Discard chunk from oldVector
-
-            while (updateChunkWrittenBytesIt != updateChunks.end() &&
-                   overlaps(*nextChunkPtr, **updateChunkWrittenBytesIt)) {
-                // Copy writtenBytes to all new overlapping chunks
-                (*updateChunkWrittenBytesIt++)
-                    ->getWritesTracker()
-                    ->addBytesWritten(nextChunkPtr->getWritesTracker()->getBytesWritten());
-            }
-
-            newMap._updateShardVersionFromDiscardedChunk(*nextChunkPtr);
-            // Since we are discarding the old chunk rather than committing,
-            // we do not update `lastCommitedIsNew` flag.
-        } else {
-            if (!newVectorPtr->empty() && lastCommittedIsNew) {
-                checkChunksAreContiguous(*newVectorPtr->back(), *nextChunkPtr);
-            }
-            lastCommittedIsNew = false;
-            newVectorPtr->emplace_back(nextChunkPtr);
-        }
-    };
-
-    const auto processUpdateChunk = [&](std::shared_ptr<ChunkInfo>&& nextChunkPtr) {
-        newMap._updateShardVersionFromUpdateChunk(*nextChunkPtr, _shardVersions);
-        uassert(ErrorCodes::ConflictingOperationInProgress,
-                str::stream() << "Changed chunk " << nextChunkPtr->toString()
-                              << " has timestamp different from that of the collection "
-                              << _collectionVersion.getTimestamp(),
-                nextChunkPtr->getLastmod().getTimestamp() == _collectionVersion.getTimestamp());
-
-        uassert(626840,
-                str::stream()
-                    << "Changed chunk " << nextChunkPtr->toString()
-                    << " doesn't have version that's greater or equal than that of the collection "
-                    << _collectionVersion.toString(),
-                _collectionVersion.isOlderOrEqualThan(nextChunkPtr->getLastmod()));
-
-        if (!newVectorPtr->empty()) {
-            checkChunksAreContiguous(*newVectorPtr->back(), *nextChunkPtr);
-        }
-        lastCommittedIsNew = true;
-        newVectorPtr->emplace_back(std::move(nextChunkPtr));
-    };
-
-    const auto processOneChunk = [&] {
-        dassert(oldChunkIt != oldVectorPtr->end() || updateChunkIt != updateChunks.end());
-        if (updateChunkIt == updateChunks.end()) {
-            // no more updates
-            processOldChunk(*(oldChunkIt++));
-            return;
-        }
-        if (oldChunkIt == oldVectorPtr->end()) {
-            // No more old chunks
-            processUpdateChunk(std::move(*(updateChunkIt++)));
-            return;
+    while (chunkMapIndex < _chunkMap.size() || changedChunkIndex < changedChunks.size()) {
+        if (chunkMapIndex >= _chunkMap.size()) {
+            validateChunkIsNotOlderThan(changedChunks[changedChunkIndex], getVersion());
+            updatedChunkMap.appendChunk(changedChunks[changedChunkIndex++]);
+            continue;
         }
 
-        const auto& oldChunk = **oldChunkIt;
-        auto& updateChunk = **updateChunkIt;
-
-        // We have both update and old chunk to peak from
-        // If they overlaps we discard the old chunk otherwise we process the one with smaller key
-        if (overlaps(updateChunk, oldChunk)) {
-            processOldChunk(*(oldChunkIt++), true /* discard */);
-            return;
-        } else {
-            // Ranges do not overlap so we yield the chunk with smaller max key
-            if (updateChunk.getMaxKeyString() < oldChunk.getMaxKeyString()) {
-                processUpdateChunk(std::move(*(updateChunkIt++)));
-                return;
-            } else {
-                processOldChunk(*(oldChunkIt++));
-                return;
-            }
+        if (changedChunkIndex >= changedChunks.size()) {
+            updatedChunkMap.appendChunk(_chunkMap[chunkMapIndex++]);
+            continue;
         }
-    };
-
-    updateChunkIt = updateChunks.begin();
-    updateChunkWrittenBytesIt = updateChunkIt;
-    // Skip first vectors that were not affected by this update since we don't need to modify them
-    auto mapIt = newMap._chunkVectorMap.upper_bound(
-        ShardKeyPattern::toKeyString((*updateChunkIt)->getRange().getMin()));
-    oldVectorPtr =
-        mapIt != newMap._chunkVectorMap.end() ? mapIt->second : std::make_shared<ChunkVector>();
-    oldChunkIt = oldVectorPtr->begin();
-    // Prepare newVector used as destination of merge sort algorithm
-    newVectorPtr = std::make_shared<ChunkVector>();
-    newVectorPtr->reserve(mapIt != newMap._chunkVectorMap.end()
-                              ? oldVectorPtr->size()
-                              : std::min(_maxChunkVectorSize, updateChunks.size()));
-    lastCommittedIsNew = false;
-
-    // Iterate until we drained all updates and old vectors
-    while (updateChunkIt != updateChunks.end() || mapIt != newMap._chunkVectorMap.end()) {
-        processOneChunk();
-
-        // Keep processing chunks until we reach the end of the current old vector
-        if (oldChunkIt == oldVectorPtr->end()) {
-            if (mapIt == newMap._chunkVectorMap.end()) {
-                // Only updates left
-                if (newVectorPtr->size() >= _maxChunkVectorSize) {
-                    auto checkMaxKeyConsistency = updateChunkIt == updateChunks.end();
-                    newMap._commitUpdatedChunkVector(std::move(newVectorPtr),
-                                                     checkMaxKeyConsistency);
-                    newVectorPtr = std::make_shared<ChunkVector>();
-                    // Allocate space only for the remaining updates
-                    newVectorPtr->reserve(newVectorPtr->size() +
-                                          std::min(_maxChunkVectorSize,
-                                                   static_cast<size_t>(std::distance(
-                                                       updateChunkIt, updateChunks.end()))));
-                }
-            } else {
-                // drained all chunks from old vector in use,
-                // remove old vector from the new map since we are going to replace it.
-                auto followingMapIt = newMap._chunkVectorMap.erase(mapIt);
-
-                // Advance the map iterator to the next old vector to update
-                mapIt = [&] {
-                    if (followingMapIt == newMap._chunkVectorMap.end()) {
-                        // No more old vector to process
-                        return newMap._chunkVectorMap.end();
-                    }
 
-                    if (updateChunkIt == updateChunks.end()) {
-                        // No more updates skip all remaining vectors
-                        return newMap._chunkVectorMap.end();
-                    }
+        auto overlap = _chunkMap[chunkMapIndex]->getRange().overlaps(
+            changedChunks[changedChunkIndex]->getRange());
 
-                    if (newVectorPtr->size() < _maxChunkVectorSize / 2) {
-                        // New vector is too small, keep accumulating next oldVector
-                        return followingMapIt;
-                    }
+        if (overlap) {
+            auto& changedChunk = changedChunks[changedChunkIndex++];
+            auto& chunkInfo = _chunkMap[chunkMapIndex];
 
-                    // next update doesn't overlap with current old vector so we need to jump
-                    // forward to the first overlapping old vector.
-                    // This is an optimization to skip vectors that are not affected by any updates.
-                    auto nextOvelappingMapIt = newMap._chunkVectorMap.upper_bound(
-                        ShardKeyPattern::toKeyString((*updateChunkIt)->getRange().getMin()));
-                    invariant(nextOvelappingMapIt != newMap._chunkVectorMap.end());
-                    return nextOvelappingMapIt;
-                }();
-
-                // Commit chunks accumulated in new vector if
-                //  - We are skipping next old vector, thus next old chunk is not adjacent to last
-                //    committed chunk
-                //  - We already reached maxChunkSize and next update is not adjacent to last
-                //    committed chunk
-                if (mapIt != followingMapIt ||
-                    (newVectorPtr->size() >= _maxChunkVectorSize &&
-                     (updateChunkIt == updateChunks.end() ||
-                      ShardKeyPattern::toKeyString((*updateChunkIt)->getRange().getMin()) !=
-                          newVectorPtr->back()->getMaxKeyString()))) {
-                    newMap._commitUpdatedChunkVector(std::move(newVectorPtr), true);
-                    newVectorPtr = std::make_shared<ChunkVector>();
-                }
+            auto bytesInReplacedChunk = chunkInfo->getWritesTracker()->getBytesWritten();
+            changedChunk->getWritesTracker()->addBytesWritten(bytesInReplacedChunk);
 
-                if (mapIt != newMap._chunkVectorMap.end()) {
-                    // Update references to oldVector
-                    oldVectorPtr = mapIt->second;
-                    oldChunkIt = oldVectorPtr->begin();
-                    // Reserve space for next chunks,
-                    // we cannot know before traversing the next old vector how many chunks will be
-                    // added to the new vector, thus this reservation is just best effort.
-                    newVectorPtr->reserve(newVectorPtr->size() + oldVectorPtr->size());
-                } else {
-                    // Only updates left, allocate space only for the remaining updates
-                    newVectorPtr->reserve(newVectorPtr->size() +
-                                          std::min(_maxChunkVectorSize,
-                                                   static_cast<size_t>(std::distance(
-                                                       updateChunkIt, updateChunks.end()))));
-                }
-            }
+            validateChunkIsNotOlderThan(changedChunk, getVersion());
+            updatedChunkMap.appendChunk(changedChunk);
+        } else {
+            updatedChunkMap.appendChunk(_chunkMap[chunkMapIndex++]);
         }
     }
 
-    if (!newVectorPtr->empty()) {
-        newMap._commitUpdatedChunkVector(std::move(newVectorPtr), true);
-    }
-
-    return newMap;
+    return updatedChunkMap;
 }
 
 BSONObj ChunkMap::toBSON() const {
     BSONObjBuilder builder;
 
     getVersion().serializeToBSON("startingVersion"_sd, &builder);
-    builder.append("chunkCount", static_cast<int64_t>(size()));
+    builder.append("chunkCount", static_cast<int64_t>(_chunkMap.size()));
 
     {
         BSONArrayBuilder arrayBuilder(builder.subarrayStart("chunks"_sd));
-        for (const auto& mapIt : _chunkVectorMap) {
-            for (const auto& chunkInfoPtr : *mapIt.second) {
-                arrayBuilder.append(chunkInfoPtr->toString());
-            }
+        for (const auto& chunk : _chunkMap) {
+            arrayBuilder.append(chunk->toString());
         }
     }
 
     return builder.obj();
 }
 
-std::string ChunkMap::toString() const {
-    StringBuilder sb;
-
-    sb << "Bucket size: " << _maxChunkVectorSize << "\n";
-    sb << "Num buckets: " << _chunkVectorMap.size() << "\n";
-    sb << "Num chunks: " << size() << "\n";
-    sb << "Chunks:\n";
-    size_t vectorCount{0};
-    for (const auto& mapIt : _chunkVectorMap) {
-        sb << "\t vector[" << vectorCount++ << "] key: " << mongo::base64::encode(mapIt.first)
-           << ", size: " << mapIt.second->size() << "\n";
-        for (const auto& chunkInfoPtr : *mapIt.second) {
-            sb << "\t" << chunkInfoPtr->toString() << '\n';
-        }
-    }
-
-    sb << "Shard versions:\n";
-    for (const auto& entry : _shardVersions) {
-        sb << "\t" << entry.first << ": " << entry.second.shardVersion.toString() << '\n';
-    }
-
-    sb << "Collection version:" << _collectionVersion.toString() << '\n';
-
-    return sb.str();
-}
-
-ChunkVector::const_iterator ChunkMap::_findIntersectingChunkIterator(
-    const std::string& shardKeyString,
-    ChunkVector::const_iterator first,
-    ChunkVector::const_iterator last,
-    bool isMaxInclusive) const {
+ChunkMap::ChunkVector::const_iterator ChunkMap::_findIntersectingChunk(const BSONObj& shardKey,
+                                                                       bool isMaxInclusive) const {
+    auto shardKeyString = ShardKeyPattern::toKeyString(shardKey);
 
     if (!isMaxInclusive) {
-        return std::lower_bound(first,
-                                last,
-                                shardKeyString,
-                                [&](const auto& chunkInfo, const std::string& shardKeyString) {
+        return std::lower_bound(_chunkMap.begin(),
+                                _chunkMap.end(),
+                                shardKey,
+                                [&shardKeyString](const auto& chunkInfo, const BSONObj& shardKey) {
                                     return chunkInfo->getMaxKeyString() < shardKeyString;
                                 });
     } else {
-        return std::upper_bound(first,
-                                last,
-                                shardKeyString,
-                                [&](const std::string& shardKeyString, const auto& chunkInfo) {
+        return std::upper_bound(_chunkMap.begin(),
+                                _chunkMap.end(),
+                                shardKey,
+                                [&shardKeyString](const BSONObj& shardKey, const auto& chunkInfo) {
                                     return shardKeyString < chunkInfo->getMaxKeyString();
                                 });
     }
 }
 
-
-std::pair<ChunkVectorMap::const_iterator, ChunkVectorMap::const_iterator>
-ChunkMap::_overlappingVectorSlotBounds(const std::string& minShardKeyStr,
-                                       const std::string& maxShardKeyStr,
-                                       bool isMaxInclusive) const {
-
-    const auto itMin = _chunkVectorMap.upper_bound(minShardKeyStr);
+std::pair<ChunkMap::ChunkVector::const_iterator, ChunkMap::ChunkVector::const_iterator>
+ChunkMap::_overlappingBounds(const BSONObj& min, const BSONObj& max, bool isMaxInclusive) const {
+    const auto itMin = _findIntersectingChunk(min);
     const auto itMax = [&]() {
-        auto it = isMaxInclusive ? _chunkVectorMap.upper_bound(maxShardKeyStr)
-                                 : _chunkVectorMap.lower_bound(maxShardKeyStr);
-
-        return it == _chunkVectorMap.end() ? it : ++it;
+        auto it = _findIntersectingChunk(max, isMaxInclusive);
+        return it == _chunkMap.end() ? it : ++it;
     }();
 
     return {itMin, itMax};
@@ -656,7 +338,7 @@ RoutingTableHistory::RoutingTableHistory(
       _maxChunkSizeBytes(maxChunkSizeBytes),
       _allowMigrations(allowMigrations),
       _chunkMap(std::move(chunkMap)),
-      _shardVersions(_chunkMap.getShardVersionsMap()) {}
+      _shardVersions(_chunkMap.constructShardVersionMap()) {}
 
 void RoutingTableHistory::setShardStale(const ShardId& shardId) {
     if (gEnableFinerGrainedCatalogCacheRefresh) {
@@ -706,7 +388,7 @@ Chunk ChunkManager::findIntersectingChunk(const BSONObj& shardKey,
     uassert(ErrorCodes::ShardKeyNotFound,
             str::stream() << "Cannot target single shard using key " << shardKey
                           << " for namespace " << _rt->optRt->nss(),
-            chunkInfo);
+            chunkInfo && chunkInfo->containsKey(shardKey));
 
     return Chunk(*chunkInfo, _clusterTime);
 }
@@ -719,14 +401,15 @@ bool ChunkManager::keyBelongsToShard(const BSONObj& shardKey, const ShardId& sha
     if (!chunkInfo)
         return false;
 
+    invariant(chunkInfo->containsKey(shardKey));
+
     return chunkInfo->getShardIdAt(_clusterTime) == shardId;
 }
 
 void ChunkManager::getShardIdsForQuery(boost::intrusive_ptr<ExpressionContext> expCtx,
                                        const BSONObj& query,
                                        const BSONObj& collation,
-                                       std::set<ShardId>* shardIds,
-                                       bool bypassIsFieldHashedCheck) const {
+                                       std::set<ShardId>* shardIds) const {
     auto findCommand = std::make_unique<FindCommandRequest>(_rt->optRt->nss());
     findCommand->setFilter(query.getOwned());
 
@@ -752,7 +435,7 @@ void ChunkManager::getShardIdsForQuery(boost::intrusive_ptr<ExpressionContext> e
     auto shardKeyToFind = _rt->optRt->getShardKeyPattern().extractShardKeyFromQuery(*cq);
     if (!shardKeyToFind.isEmpty()) {
         try {
-            auto chunk = findIntersectingChunk(shardKeyToFind, collation, bypassIsFieldHashedCheck);
+            auto chunk = findIntersectingChunk(shardKeyToFind, collation);
             shardIds->insert(chunk.getShardId());
             return;
         } catch (const DBException&) {
@@ -792,7 +475,7 @@ void ChunkManager::getShardIdsForQuery(boost::intrusive_ptr<ExpressionContext> e
     // For now, we satisfy that assumption by adding a shard with no matches rather than returning
     // an empty set of shards.
     if (shardIds->empty()) {
-        _rt->optRt->forEachChunk([&](const auto& chunkInfo) {
+        _rt->optRt->forEachChunk([&](const std::shared_ptr<ChunkInfo>& chunkInfo) {
             shardIds->insert(chunkInfo->getShardIdAt(_clusterTime));
             return false;
         });
@@ -812,7 +495,7 @@ void ChunkManager::getShardIdsForRange(const BSONObj& min,
         return;
     }
 
-    _rt->optRt->forEachOverlappingChunk(min, max, true, [&](const auto& chunkInfo) {
+    _rt->optRt->forEachOverlappingChunk(min, max, true, [&](auto& chunkInfo) {
         shardIds->insert(chunkInfo->getShardIdAt(_clusterTime));
 
         // No need to iterate through the rest of the ranges, because we already know we need to use
@@ -832,7 +515,7 @@ bool ChunkManager::rangeOverlapsShard(const ChunkRange& range, const ShardId& sh
     bool overlapFound = false;
 
     _rt->optRt->forEachOverlappingChunk(
-        range.getMin(), range.getMax(), false, [&](const auto& chunkInfo) {
+        range.getMin(), range.getMax(), false, [&](auto& chunkInfo) {
             if (chunkInfo->getShardIdAt(_clusterTime) == shardId) {
                 overlapFound = true;
                 return false;
@@ -849,7 +532,7 @@ boost::optional<Chunk> ChunkManager::getNextChunkOnShard(const BSONObj& shardKey
     boost::optional<Chunk> chunk;
 
     _rt->optRt->forEachChunk(
-        [&](const auto& chunkInfo) {
+        [&](auto& chunkInfo) {
             if (chunkInfo->getShardIdAt(_clusterTime) == shardId) {
                 chunk.emplace(*chunkInfo, _clusterTime);
                 return false;
@@ -922,7 +605,7 @@ IndexBounds ChunkManager::getIndexBoundsForQuery(const BSONObj& key,
     // Use query framework to generate index bounds
     QueryPlannerParams plannerParams;
     // Must use "shard key" index
-    plannerParams.options = QueryPlannerParams::STRICT_NO_TABLE_SCAN;
+    plannerParams.options = QueryPlannerParams::NO_TABLE_SCAN;
     IndexEntry indexEntry(key,
                           indexType,
                           IndexDescriptor::kLatestIndexVersion,
@@ -1051,15 +734,21 @@ std::string ChunkManager::toString() const {
     return _rt->optRt ? _rt->optRt->toString() : "UNSHARDED";
 }
 
-ShardVersionTargetingInfo RoutingTableHistory::_getVersion(const ShardId& shardName,
-                                                           bool throwOnStaleShard) const {
+bool RoutingTableHistory::compatibleWith(const RoutingTableHistory& other,
+                                         const ShardId& shardName) const {
+    // Return true if the shard version is the same in the two chunk managers
+    // TODO: This doesn't need to be so strong, just major vs
+    return other.getVersion(shardName) == getVersion(shardName);
+}
+
+ChunkVersion RoutingTableHistory::_getVersion(const ShardId& shardName,
+                                              bool throwOnStaleShard) const {
     auto it = _shardVersions.find(shardName);
     if (it == _shardVersions.end()) {
         // Shards without explicitly tracked shard versions (meaning they have no chunks) always
         // have a version of (0, 0, epoch, timestamp)
         const auto collVersion = _chunkMap.getVersion();
-        return ShardVersionTargetingInfo(
-            ChunkVersion(0, 0, collVersion.epoch(), collVersion.getTimestamp()), Timestamp(0, 0));
+        return ChunkVersion(0, 0, collVersion.epoch(), collVersion.getTimestamp());
     }
 
     if (throwOnStaleShard && gEnableFinerGrainedCatalogCacheRefresh) {
@@ -1068,21 +757,30 @@ ShardVersionTargetingInfo RoutingTableHistory::_getVersion(const ShardId& shardN
                 !it->second.isStale.load());
     }
 
-    const auto& shardVersionTargetingInfo = it->second;
-    return ShardVersionTargetingInfo(shardVersionTargetingInfo.shardVersion,
-                                     shardVersionTargetingInfo.validAfter);
+    return it->second.shardVersion;
+}
+
+ChunkVersion RoutingTableHistory::getVersion(const ShardId& shardName) const {
+    return _getVersion(shardName, true);
+}
+
+ChunkVersion RoutingTableHistory::getVersionForLogging(const ShardId& shardName) const {
+    return _getVersion(shardName, false);
 }
 
 std::string RoutingTableHistory::toString() const {
     StringBuilder sb;
     sb << "RoutingTableHistory: " << _nss.ns() << " key: " << _shardKeyPattern.toString() << '\n';
 
-    sb << _chunkMap.toString();
+    sb << "Chunks:\n";
+    _chunkMap.forEach([&sb](const auto& chunk) {
+        sb << "\t" << chunk->toString() << '\n';
+        return true;
+    });
 
     sb << "Shard versions:\n";
     for (const auto& entry : _shardVersions) {
-        sb << "\t" << entry.first << ": " << entry.second.shardVersion.toString() << " @ "
-           << entry.second.validAfter.toString() << '\n';
+        sb << "\t" << entry.first << ": " << entry.second.shardVersion.toString() << '\n';
     }
 
     return sb.str();
@@ -1103,19 +801,16 @@ RoutingTableHistory RoutingTableHistory::makeNew(
     const std::vector<ChunkType>& chunks) {
 
     auto changedChunkInfos = flatten(chunks);
-
-    return RoutingTableHistory(
-        std::move(nss),
-        std::move(uuid),
-        std::move(shardKeyPattern),
-        std::move(defaultCollator),
-        std::move(unique),
-        std::move(timeseriesFields),
-        std::move(reshardingFields),
-        boost::none,
-        allowMigrations,
-        ChunkMap{epoch, timestamp, static_cast<size_t>(gRoutingTableCacheChunkBucketSize)}
-            .createMerged(std::move(changedChunkInfos)));
+    return RoutingTableHistory(std::move(nss),
+                               std::move(uuid),
+                               std::move(shardKeyPattern),
+                               std::move(defaultCollator),
+                               std::move(unique),
+                               std::move(timeseriesFields),
+                               std::move(reshardingFields),
+                               maxChunkSizeBytes,
+                               allowMigrations,
+                               ChunkMap{epoch, timestamp}.createMerged(changedChunkInfos));
 }
 
 // Note that any new parameters added to RoutingTableHistory::makeUpdated() must also be added to
@@ -1129,7 +824,7 @@ RoutingTableHistory RoutingTableHistory::makeUpdated(
     const std::vector<ChunkType>& changedChunks) const {
 
     auto changedChunkInfos = flatten(changedChunks);
-    auto chunkMap = _chunkMap.createMerged(std::move(changedChunkInfos));
+    auto chunkMap = _chunkMap.createMerged(changedChunkInfos);
 
     // Only update the same collection.
     invariant(getVersion().isSameCollection(chunkMap.getVersion()));
diff --git a/src/mongo/s/chunk_manager.h b/src/mongo/s/chunk_manager.h
index 39755b418a9..00c75957d37 100644
--- a/src/mongo/s/chunk_manager.h
+++ b/src/mongo/s/chunk_manager.h
@@ -41,6 +41,7 @@
 #include "mongo/s/resharding/type_collection_fields_gen.h"
 #include "mongo/s/shard_key_pattern.h"
 #include "mongo/s/type_collection_common_types_gen.h"
+#include "mongo/stdx/unordered_map.h"
 #include "mongo/util/concurrency/ticketholder.h"
 #include "mongo/util/read_through_cache.h"
 
@@ -51,24 +52,13 @@ struct QuerySolutionNode;
 class ChunkManager;
 
 struct ShardVersionTargetingInfo {
-    ShardVersionTargetingInfo(const ShardVersionTargetingInfo& other)
-        : shardVersion(other.shardVersion),
-          validAfter(other.validAfter),
-          isStale(other.isStale.load()) {}
-
-    ShardVersionTargetingInfo(const OID& epoch, const Timestamp& timestamp);
-    ShardVersionTargetingInfo(ChunkVersion shardVersion, Timestamp validAfter)
-        : shardVersion(std::move(shardVersion)), validAfter(std::move(validAfter)) {}
+    // Indicates whether the shard is stale and thus needs a catalog cache refresh
+    AtomicWord<bool> isStale{false};
 
     // Max chunk version for the shard
     ChunkVersion shardVersion;
 
-    // Max validAfter for the shard, effectively this is the timestamp of the latest placement
-    // change that occurred on a particular shard.
-    Timestamp validAfter;
-
-    // Indicates whether the shard is stale and thus needs a catalog cache refresh
-    AtomicWord<bool> isStale{false};
+    ShardVersionTargetingInfo(const OID& epoch, const Timestamp& timestamp);
 };
 
 // Map from a shard to a struct indicating both the max chunk version on that shard and whether the
@@ -81,174 +71,73 @@ using ShardVersionMap = stdx::unordered_map<ShardId, ShardVersionTargetingInfo,
  * underlying implementation.
  */
 class ChunkMap {
-public:
-    // Vector of chunks ordered by max key in ascending order.
+    // Vector of chunks ordered by max key.
     using ChunkVector = std::vector<std::shared_ptr<ChunkInfo>>;
-    using ChunkVectorMap = std::map<std::string, std::shared_ptr<ChunkVector>>;
-
-    explicit ChunkMap(OID epoch, const Timestamp& timestamp, size_t chunkVectorSize)
-        : _collectionVersion(0, 0, epoch, timestamp),
-          _collTimestamp(timestamp),
-          _maxChunkVectorSize(chunkVectorSize) {}
 
-    size_t size() const;
-
-    // Max version across all chunks
-    ChunkVersion getVersion() const {
-        return _collectionVersion;
-    }
-
-    size_t getMaxChunkVectorSize() const {
-        return _maxChunkVectorSize;
+public:
+    explicit ChunkMap(OID epoch, const Timestamp& timestamp, size_t initialCapacity = 0)
+        : _collectionVersion(0, 0, epoch, timestamp), _collTimestamp(timestamp) {
+        _chunkMap.reserve(initialCapacity);
     }
 
-    const ShardVersionMap& getShardVersionsMap() const {
-        return _shardVersions;
+    size_t size() const {
+        return _chunkMap.size();
     }
 
-    const ChunkVectorMap& getChunkVectorMap() const {
-        return _chunkVectorMap;
+    ChunkVersion getVersion() const {
+        return _collectionVersion;
     }
 
-
-    /*
-     * Invoke the given handler for each std::shared_ptr<ChunkInfo> contained in this chunk map
-     * until either all matching chunks have been processed or @handler returns false.
-     *
-     * Chunks are yielded in ascending order of shardkey (e.g. minKey to maxKey);
-     *
-     * When shardKey is provided the function will start yileding from the chunk that contains the
-     * given shard key.
-     */
     template <typename Callable>
     void forEach(Callable&& handler, const BSONObj& shardKey = BSONObj()) const {
-        if (shardKey.isEmpty()) {
-            for (const auto& mapIt : _chunkVectorMap) {
-                for (const auto& chunkInfoPtr : *(mapIt.second)) {
-                    if (!handler(chunkInfoPtr))
-                        return;
-                }
-            }
-
-            return;
-        }
+        auto it = shardKey.isEmpty() ? _chunkMap.begin() : _findIntersectingChunk(shardKey);
 
-        auto shardKeyString = ShardKeyPattern::toKeyString(shardKey);
-
-        const auto mapItBegin = _chunkVectorMap.upper_bound(shardKeyString);
-        for (auto mapIt = mapItBegin; mapIt != _chunkVectorMap.end(); mapIt++) {
-            const auto& chunkVector = *(mapIt->second);
-            auto it = mapIt == mapItBegin ? _findIntersectingChunkIterator(shardKeyString,
-                                                                           chunkVector.begin(),
-                                                                           chunkVector.end(),
-                                                                           true /*isMaxInclusive*/)
-                                          : chunkVector.begin();
-            for (; it != chunkVector.end(); ++it) {
-                if (!handler(*it))
-                    return;
-            }
+        for (; it != _chunkMap.end(); ++it) {
+            if (!handler(*it))
+                break;
         }
     }
 
-
-    /*
-     * Invoke the given @handler for each std::shared_ptr<ChunkInfo> that overlaps with range [@min,
-     * @max] until either all matching chunks have been processed or @handler returns false.
-     *
-     * Chunks are yielded in ascending order of shardkey (e.g. minKey to maxKey);
-     *
-     * When @isMaxInclusive is true also the chunk whose minKey is equal to @max will be yielded.
-     */
     template <typename Callable>
     void forEachOverlappingChunk(const BSONObj& min,
                                  const BSONObj& max,
                                  bool isMaxInclusive,
                                  Callable&& handler) const {
-        const auto minShardKeyStr = ShardKeyPattern::toKeyString(min);
-        const auto maxShardKeyStr = ShardKeyPattern::toKeyString(max);
-        const auto bounds =
-            _overlappingVectorSlotBounds(minShardKeyStr, maxShardKeyStr, isMaxInclusive);
-        for (auto mapIt = bounds.first; mapIt != bounds.second; ++mapIt) {
-
-            const auto& chunkVector = *(mapIt->second);
-
-            const auto chunkItBegin = [&] {
-                if (mapIt == bounds.first) {
-                    // On first vector we need to start from chunk that contain the given minKey
-                    return _findIntersectingChunkIterator(minShardKeyStr,
-                                                          chunkVector.begin(),
-                                                          chunkVector.end(),
-                                                          true /* isMaxInclusive */);
-                }
-                return chunkVector.begin();
-            }();
-
-            const auto chunkItEnd = [&] {
-                if (mapIt == std::prev(bounds.second)) {
-                    // On last vector we need to skip all chunks that are greater than the give
-                    // maxKey
-                    auto it = _findIntersectingChunkIterator(
-                        maxShardKeyStr, chunkItBegin, chunkVector.end(), isMaxInclusive);
-                    return it == chunkVector.end() ? it : ++it;
-                }
-                return chunkVector.end();
-            }();
-
-            for (auto chunkIt = chunkItBegin; chunkIt != chunkItEnd; ++chunkIt) {
-                if (!handler(*chunkIt))
-                    return;
-            }
+        const auto bounds = _overlappingBounds(min, max, isMaxInclusive);
+
+        for (auto it = bounds.first; it != bounds.second; ++it) {
+            if (!handler(*it))
+                break;
         }
     }
 
+    ShardVersionMap constructShardVersionMap() const;
     std::shared_ptr<ChunkInfo> findIntersectingChunk(const BSONObj& shardKey) const;
 
-    ChunkMap createMerged(ChunkVector changedChunks) const;
+    void appendChunk(const std::shared_ptr<ChunkInfo>& chunk);
 
-    BSONObj toBSON() const;
+    ChunkMap createMerged(const std::vector<std::shared_ptr<ChunkInfo>>& changedChunks) const;
 
-    std::string toString() const;
+    BSONObj toBSON() const;
 
 private:
-    ChunkVector::const_iterator _findIntersectingChunkIterator(const std::string& shardKeyString,
-                                                               ChunkVector::const_iterator first,
-                                                               ChunkVector::const_iterator last,
-                                                               bool isMaxInclusive) const;
-
-    std::pair<ChunkVectorMap::const_iterator, ChunkVectorMap::const_iterator>
-    _overlappingVectorSlotBounds(const std::string& minShardKeyStr,
-                                 const std::string& maxShardKeyStr,
-                                 bool isMaxInclusive) const;
-    ChunkMap _makeUpdated(ChunkVector&& changedChunks) const;
-
-    void _updateShardVersionFromDiscardedChunk(const ChunkInfo& chunk);
-    void _updateShardVersionFromUpdateChunk(const ChunkInfo& chunk,
-                                            const ShardVersionMap& oldShardVersions);
-    void _commitUpdatedChunkVector(std::shared_ptr<ChunkVector>&& chunkVectorPtr,
-                                   bool checkMaxKeyConsistency);
-    void _mergeAndCommitUpdatedChunkVector(ChunkVectorMap::const_iterator pos,
-                                           std::shared_ptr<ChunkVector>&& chunkVectorPtr);
-    void _splitAndCommitUpdatedChunkVector(ChunkVectorMap::const_iterator pos,
-                                           std::shared_ptr<ChunkVector>&& chunkVectorPtr);
-
-    ChunkVectorMap _chunkVectorMap;
+    ChunkVector::const_iterator _findIntersectingChunk(const BSONObj& shardKey,
+                                                       bool isMaxInclusive = true) const;
+    std::pair<ChunkVector::const_iterator, ChunkVector::const_iterator> _overlappingBounds(
+        const BSONObj& min, const BSONObj& max, bool isMaxInclusive) const;
+
+    ChunkVector _chunkMap;
 
     // Max version across all chunks
     ChunkVersion _collectionVersion;
 
-    // The representation of shard versions and staleness indicators for this namespace. If a
-    // shard does not exist, it will not have an entry in the map.
-    // Note: this declaration must not be moved before _chunkMap since it is initialized by using
-    // the _chunkVectorMap instance.
-    ShardVersionMap _shardVersions;
-
     // Represents the timestamp present in config.collections for this ChunkMap.
+    //
+    // Note that due to the way Phase 1 of the FCV upgrade writes timestamps to chunks
+    // (non-atomically), it is possible that chunks exist with timestamps, but the corresponding
+    // config.collections entry doesn't. In this case, the chunks timestamp should be ignored when
+    // computing the collection version and we should use _collTimestamp instead.
     Timestamp _collTimestamp;
-
-    // Maximum size of chunk vectors stored in the chunk vector map.
-    // Bigger vectors will imply slower incremental refreshes (more chunks to copy) but
-    // faster map copy (less chunk vector pointers to copy).
-    size_t _maxChunkVectorSize;
 };
 
 /**
@@ -339,7 +228,6 @@ public:
      */
     void setAllShardsRefreshed();
 
-    // Max version across all chunks
     ChunkVersion getVersion() const {
         return _chunkMap.getVersion();
     }
@@ -348,26 +236,14 @@ public:
      * Retrieves the shard version for the given shard. Will throw a ShardInvalidatedForTargeting
      * exception if the shard is marked as stale.
      */
-    ChunkVersion getVersion(const ShardId& shardId) const {
-        return _getVersion(shardId, true).shardVersion;
-    }
+    ChunkVersion getVersion(const ShardId& shardId) const;
 
     /**
      * Retrieves the shard version for the given shard. Will not throw if the shard is marked as
      * stale. Only use when logging the given chunk version -- if the caller must execute logic
      * based on the returned version, use getVersion() instead.
      */
-    ChunkVersion getVersionForLogging(const ShardId& shardId) const {
-        return _getVersion(shardId, false).shardVersion;
-    }
-
-    /**
-     * Retrieves the maximum validAfter timestamp for the given shard. Will throw a
-     * ShardInvalidatedForTargeting exception if the shard is marked as stale.
-     */
-    Timestamp getMaxValidAfter(const ShardId& shardId) const {
-        return _getVersion(shardId, true).validAfter;
-    }
+    ChunkVersion getVersionForLogging(const ShardId& shardId) const;
 
     size_t numChunks() const {
         return _chunkMap.size();
@@ -401,6 +277,11 @@ public:
      */
     int getNShardsOwningChunks() const;
 
+    /**
+     * Returns true if, for this shard, the chunks are identical in both chunk managers
+     */
+    bool compatibleWith(const RoutingTableHistory& other, const ShardId& shard) const;
+
     std::string toString() const;
 
     bool uuidMatches(const UUID& uuid) const {
@@ -442,7 +323,7 @@ private:
                         bool allowMigrations,
                         ChunkMap chunkMap);
 
-    ShardVersionTargetingInfo _getVersion(const ShardId& shardId, bool throwOnStaleShard) const;
+    ChunkVersion _getVersion(const ShardId& shardName, bool throwOnStaleShard) const;
 
     // Namespace to which this routing information corresponds
     NamespaceString _nss;
@@ -675,27 +556,10 @@ public:
         return _rt->optRt->getVersion();
     }
 
-    /**
-     * Retrieves the placement version for the given shard. Will throw a
-     * ShardInvalidatedForTargeting exception if the shard is marked as stale.
-     */
     ChunkVersion getVersion(const ShardId& shardId) const {
         return _rt->optRt->getVersion(shardId);
     }
 
-    /**
-     * Retrieves the maximum validAfter timestamp for the given shard. Will throw a
-     * ShardInvalidatedForTargeting exception if the shard is marked as stale.
-     */
-    Timestamp getMaxValidAfter(const ShardId& shardId) const {
-        return _rt->optRt->getMaxValidAfter(shardId);
-    }
-
-    /**
-     * Retrieves the placement version for the given shard. Will not throw if the shard is marked as
-     * stale. Only use when logging the given chunk version -- if the caller must execute logic
-     * based on the returned version, use getVersion() instead.
-     */
     ChunkVersion getVersionForLogging(const ShardId& shardId) const {
         return _rt->optRt->getVersionForLogging(shardId);
     }
@@ -711,23 +575,6 @@ public:
             });
     }
 
-    template <typename Callable>
-    void forEachOverlappingChunk(const BSONObj& min,
-                                 const BSONObj& max,
-                                 bool isMaxInclusive,
-                                 Callable&& handler) const {
-        _rt->optRt->forEachOverlappingChunk(
-            min,
-            max,
-            isMaxInclusive,
-            [this, handler = std::forward<Callable>(handler)](const auto& chunkInfo) mutable {
-                if (!handler(Chunk{*chunkInfo, _clusterTime})) {
-                    return false;
-                }
-                return true;
-            });
-    }
-
     /**
      * Returns true if a document with the given "shardKey" is owned by the shard with the given
      * "shardId" in this routing table. If "shardKey" is empty returns false. If "shardKey" is not a
@@ -778,15 +625,12 @@ public:
 
     /**
      * Finds the shard IDs for a given filter and collation. If collation is empty, we use the
-     * collection default collation for targeting. If 'bypassIsFieldHashedCheck' is true, it skips
-     * checking if the shard key was hashed and assumes that any non-collatable shard key was not
-     * hashed from a collatable type.
+     * collection default collation for targeting.
      */
     void getShardIdsForQuery(boost::intrusive_ptr<ExpressionContext> expCtx,
                              const BSONObj& query,
                              const BSONObj& collation,
-                             std::set<ShardId>* shardIds,
-                             bool bypassIsFieldHashedCheck = false) const;
+                             std::set<ShardId>* shardIds) const;
 
     /**
      * Returns all shard ids which contain chunks overlapping the range [min, max]. Please note the
@@ -835,6 +679,13 @@ public:
      */
     static ChunkManager makeAtTime(const ChunkManager& cm, Timestamp clusterTime);
 
+    /**
+     * Returns true if, for this shard, the chunks are identical in both chunk managers
+     */
+    bool compatibleWith(const ChunkManager& other, const ShardId& shard) const {
+        return _rt->optRt->compatibleWith(*other._rt->optRt, shard);
+    }
+
     bool uuidMatches(const UUID& uuid) const {
         return _rt->optRt->uuidMatches(uuid);
     }
diff --git a/src/mongo/s/chunk_manager_refresh_bm.cpp b/src/mongo/s/chunk_manager_refresh_bm.cpp
index c3577944fab..3c7f3adb6b3 100644
--- a/src/mongo/s/chunk_manager_refresh_bm.cpp
+++ b/src/mongo/s/chunk_manager_refresh_bm.cpp
@@ -50,17 +50,17 @@ RoutingTableHistoryValueHandle makeStandaloneRoutingTableHistory(RoutingTableHis
         ComparableChunkVersion::makeComparableChunkVersion(version));
 }
 
-ShardId getShardId(int i) {
-    return {std::string(str::stream() << "shard_" << i)};
-}
-
 ChunkRange getRangeForChunk(int i, int nChunks) {
     invariant(i >= 0);
     invariant(nChunks > 0);
     invariant(i < nChunks);
-    auto min = (i == 0) ? BSON("_id" << MINKEY) : BSON("_id" << (i - 1) * 100);
-    auto max = (i == nChunks - 1) ? BSON("_id" << MAXKEY) : BSON("_id" << i * 100);
-    return {std::move(min), std::move(max)};
+    if (i == 0) {
+        return {BSON("_id" << MINKEY), BSON("_id" << 0)};
+    }
+    if (i + 1 == nChunks) {
+        return {BSON("_id" << (i - 1) * 100), BSON("_id" << MAXKEY)};
+    }
+    return {BSON("_id" << (i - 1) * 100), BSON("_id" << i * 100)};
 }
 
 template <typename ShardSelectorFn>
@@ -93,21 +93,21 @@ CollectionMetadata makeChunkManagerWithShardSelector(int nShards,
                                            boost::none /* chunkSizeBytes */,
                                            true,
                                            chunks);
-    return CollectionMetadata(ChunkManager(getShardId(0),
+    return CollectionMetadata(ChunkManager(ShardId("Shard0"),
                                            DatabaseVersion(UUID::gen(), Timestamp(1, 0)),
                                            makeStandaloneRoutingTableHistory(std::move(rt)),
                                            boost::none),
-                              getShardId(0));
+                              ShardId("shard0"));
 }
 
 ShardId pessimalShardSelector(int i, int nShards, int nChunks) {
-    return getShardId(i % nShards);
+    return ShardId(str::stream() << "shard" << (i % nShards));
 }
 
 ShardId optimalShardSelector(int i, int nShards, int nChunks) {
     invariant(nShards <= nChunks);
     const auto shardNum = (int64_t(i) * nShards / nChunks) % nShards;
-    return getShardId(shardNum);
+    return ShardId(str::stream() << "shard" << shardNum);
 }
 
 MONGO_COMPILER_NOINLINE auto makeChunkManagerWithPessimalBalancedDistribution(int nShards,
@@ -124,133 +124,35 @@ MONGO_COMPILER_NOINLINE auto runIncrementalUpdate(const CollectionMetadata& cm,
                                                   const std::vector<ChunkType>& newChunks) {
     auto rt = cm.getChunkManager()->getRoutingTableHistory_ForTest().makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, newChunks);
-    return CollectionMetadata(ChunkManager(getShardId(0),
+    return CollectionMetadata(ChunkManager(ShardId("shard0"),
                                            DatabaseVersion(UUID::gen(), Timestamp(1, 0)),
                                            makeStandaloneRoutingTableHistory(std::move(rt)),
                                            boost::none),
-                              getShardId(0));
+                              ShardId("shard0"));
 }
 
-/*
- * Simulate a refresh of the ChunkManager where a number of chunks is migrated from one shard to
- * another.
- *
- * The chunks modified in the routing table are equally spaced.
- */
-void BM_IncrementalSpacedRefreshMoveChunks(benchmark::State& state) {
+void BM_IncrementalRefreshOfPessimalBalancedDistribution(benchmark::State& state) {
     const int nShards = state.range(0);
     const int nChunks = state.range(1);
-    const int nUpdates = state.range(2);
     auto metadata = makeChunkManagerWithPessimalBalancedDistribution(nShards, nChunks);
 
-    auto lastVersion = metadata.getCollVersion();
-
+    auto postMoveVersion = metadata.getChunkManager()->getVersion();
+    const UUID uuid = metadata.getUUID();
     std::vector<ChunkType> newChunks;
-    newChunks.reserve(nUpdates);
-    const auto updateSpacing = nChunks / nUpdates;
-    for (int i = 0; i < nUpdates; i++) {
-        const auto idx = i * updateSpacing;
-        lastVersion.incMajor();
-        newChunks.emplace_back(metadata.getUUID(),
-                               getRangeForChunk(idx, nChunks),
-                               lastVersion,
-                               pessimalShardSelector(idx, nShards, nChunks));
-    }
-
-    std::mt19937 g;
-    g.seed(456);
-    std::shuffle(newChunks.begin(), newChunks.end(), g);
-
-    for (auto _ : state) {
-        benchmark::DoNotOptimize(runIncrementalUpdate(metadata, newChunks));
-    }
-}
-
-BENCHMARK(BM_IncrementalSpacedRefreshMoveChunks)
-    ->Args({4, 1, 1})
-    ->Args({4, 10, 1})
-    ->Args({4, 100, 1})
-    ->Args({4, 1000, 1})
-    ->Args({4, 10000, 1})
-    ->Args({4, 100000, 1})
-    ->Args({4, 10000, 10})
-    ->Args({4, 10000, 100})
-    ->Args({4, 10000, 1000})
-    ->Args({4, 10000, 10000});
-
-/*
- * Simulate a refresh of the ChunkManager where a number of chunks is merged together.
- */
-void BM_IncrementalSpacedRefreshMergeChunks(benchmark::State& state) {
-    const int nShards = state.range(0);
-    const int nChunks = state.range(1);
-    const int nUpdates = state.range(2);
-    auto metadata = makeChunkManagerWithOptimalBalancedDistribution(nShards, nChunks);
-
-    auto lastVersion = metadata.getCollVersion();
+    postMoveVersion.incMajor();
+    newChunks.emplace_back(uuid, getRangeForChunk(1, nChunks), postMoveVersion, ShardId("shard0"));
+    postMoveVersion.incMajor();
+    newChunks.emplace_back(uuid, getRangeForChunk(3, nChunks), postMoveVersion, ShardId("shard1"));
 
-    std::vector<ChunkType> newChunks;
-    newChunks.reserve(nUpdates);
-    invariant(nUpdates <= nShards);
-    const auto shardSpacing = nShards / (nUpdates + 1);
-    std::set<ShardId> shardsToMerge;
-    for (int i = 0; i < nUpdates; i++) {
-        invariant(i * shardSpacing <= nShards);
-        shardsToMerge.emplace(getShardId(i * shardSpacing));
-    }
-
-    ShardId shardId;
-    std::vector<ChunkRange> rangesToMerge;
-
-    const auto flushRanges = [&] {
-        if (rangesToMerge.empty()) {
-            return;
-        }
-
-        lastVersion.incMajor();
-        newChunks.emplace_back(
-            metadata.getUUID(),
-            ChunkRange(rangesToMerge.front().getMin(), rangesToMerge.back().getMax()),
-            lastVersion,
-            shardId);
-        rangesToMerge.clear();
-    };
-
-    for (int i = 0; i < nChunks; i++) {
-        auto nextShardId = pessimalShardSelector(i, nShards, nChunks);
-        if (nextShardId != shardId) {
-            flushRanges();
-            shardId = nextShardId;
-        }
-        if (shardsToMerge.count(shardId) == 1) {
-            rangesToMerge.emplace_back(getRangeForChunk(i, nChunks));
-        }
-    }
-    flushRanges();
-
-    std::mt19937 g;
-    g.seed(456);
-    std::shuffle(newChunks.begin(), newChunks.end(), g);
-
-    for (auto _ : state) {
+    for (auto keepRunning : state) {
         benchmark::DoNotOptimize(runIncrementalUpdate(metadata, newChunks));
     }
 }
 
-/*
- * Simulate chunks merge on a routing table of 10000 chunks partitioned among 4 shards.
- *
- * [   0, 2500)  -> shard0
- * [2500, 5000)  -> shard1
- * [5000, 7500)  -> shard2
- * [7500, 10000) -> shard3
- */
-
-BENCHMARK(BM_IncrementalSpacedRefreshMergeChunks)
-    ->Args({4, 10000, 1})   // merge all chunks on shard2
-    ->Args({4, 10000, 2})   // merge all chunks on shard2 and shard3
-    ->Args({4, 10000, 3})   // merge all chunks on shard1, shard2 and shard3
-    ->Args({4, 10000, 4});  // merge all chunks on shard1, shard2, shard3 and shard4
+BENCHMARK(BM_IncrementalRefreshOfPessimalBalancedDistribution)
+    ->Args({2, 50000})
+    ->Args({2, 250000})
+    ->Args({2, 500000});
 
 template <typename ShardSelectorFn>
 auto BM_FullBuildOfChunkManager(benchmark::State& state, ShardSelectorFn selectShard) {
@@ -285,11 +187,11 @@ auto BM_FullBuildOfChunkManager(benchmark::State& state, ShardSelectorFn selectS
                                                true,
                                                chunks);
         benchmark::DoNotOptimize(
-            CollectionMetadata(ChunkManager(getShardId(0),
+            CollectionMetadata(ChunkManager(ShardId("shard0"),
                                             DatabaseVersion(UUID::gen(), Timestamp(1, 0)),
                                             makeStandaloneRoutingTableHistory(std::move(rt)),
                                             boost::none),
-                               getShardId(0)));
+                               ShardId("shard0")));
     }
 }
 
@@ -511,14 +413,11 @@ MONGO_INITIALIZER(RegisterBenchmarks)(InitializerContext* context) {
     };
 
     for (auto bmCase : bmCases) {
-        bmCase->Args({2, 2})
-            ->Args({1, 10000})
-            ->Args({10, 10000})
-            ->Args({100, 10000})
-            ->Args({1000, 10000})
-            ->Args({10, 10})
-            ->Args({10, 100})
-            ->Args({10, 1000});
+        bmCase->Args({2, 50000})
+            ->Args({10, 50000})
+            ->Args({100, 50000})
+            ->Args({1000, 50000})
+            ->Args({2, 2});
     }
 }
 
diff --git a/src/mongo/s/chunk_manager_targeter.cpp b/src/mongo/s/chunk_manager_targeter.cpp
index f750554ea56..bdb386420c6 100644
--- a/src/mongo/s/chunk_manager_targeter.cpp
+++ b/src/mongo/s/chunk_manager_targeter.cpp
@@ -43,8 +43,6 @@
 #include "mongo/db/query/canonical_query.h"
 #include "mongo/db/query/collation/collation_index_key.h"
 #include "mongo/db/query/collation/collator_factory_interface.h"
-#include "mongo/db/stats/counters.h"
-#include "mongo/db/timeseries/metadata.h"
 #include "mongo/db/timeseries/timeseries_constants.h"
 #include "mongo/db/timeseries/timeseries_options.h"
 #include "mongo/db/timeseries/timeseries_update_delete_util.h"
@@ -65,8 +63,6 @@
 namespace mongo {
 namespace {
 
-MONGO_FAIL_POINT_DEFINE(waitForDatabaseToBeDropped);
-
 enum CompareResult { CompareResult_Unknown, CompareResult_GTE, CompareResult_LT };
 
 constexpr auto kIdFieldName = "_id"_sd;
@@ -230,8 +226,6 @@ bool isMetadataDifferent(const ChunkManager& managerA, const ChunkManager& manag
 
 }  // namespace
 
-const size_t ChunkManagerTargeter::kMaxDatabaseCreationAttempts = 3;
-
 ChunkManagerTargeter::ChunkManagerTargeter(OperationContext* opCtx,
                                            const NamespaceString& nss,
                                            boost::optional<OID> targetEpoch)
@@ -245,45 +239,13 @@ ChunkManagerTargeter::ChunkManagerTargeter(OperationContext* opCtx,
  * user request is on the view namespace, we implicity tranform the request to the buckets namepace.
  */
 ChunkManager ChunkManagerTargeter::_init(OperationContext* opCtx, bool refresh) {
-    const auto createDatabaseAndGetRoutingInfo = [&opCtx, &refresh](const NamespaceString& nss) {
-        size_t attempts = 1;
-        while (true) {
-            try {
-                cluster::createDatabase(opCtx, nss.db());
-
-                if (refresh) {
-                    uassertStatusOK(
-                        Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfoWithRefresh(opCtx,
-                                                                                              nss));
-                }
-
-                if (MONGO_unlikely(waitForDatabaseToBeDropped.shouldFail())) {
-                    LOGV2(8314600, "Hanging due to waitForDatabaseToBeDropped fail point");
-                    waitForDatabaseToBeDropped.pauseWhileSet(opCtx);
-                }
-
-                return uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, nss));
-            } catch (const ExceptionFor<ErrorCodes::NamespaceNotFound>&) {
-                LOGV2_INFO(8314601,
-                           "Failed initialization of routing info because the database has been "
-                           "concurrently dropped",
-                           logAttrs(nss),
-                           "attemptNumber"_attr = attempts,
-                           "maxAttempts"_attr = kMaxDatabaseCreationAttempts);
-
-                if (attempts++ >= kMaxDatabaseCreationAttempts) {
-                    // The maximum number of attempts has been reached, so the procedure fails as it
-                    // could be a logical error. At this point, it is unlikely that the error is
-                    // caused by concurrent drop database operations.
-                    throw;
-                }
-            }
-        }
-    };
+    cluster::createDatabase(opCtx, _nss.db());
 
-    createDatabaseAndGetRoutingInfo(_nss);
-
-    auto cm = createDatabaseAndGetRoutingInfo(_nss);
+    if (refresh) {
+        uassertStatusOK(
+            Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfoWithRefresh(opCtx, _nss));
+    }
+    auto cm = uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, _nss));
 
     // For a sharded time-series collection, only the underlying buckets collection is stored on the
     // config servers. If the user operation is on the time-series view namespace, we should check
@@ -299,18 +261,27 @@ ChunkManager ChunkManagerTargeter::_init(OperationContext* opCtx, bool refresh)
     //    back to the view namespace and reset '_isRequestOnTimeseriesViewNamespace'.
     if (!cm.isSharded() && !_nss.isTimeseriesBucketsCollection()) {
         auto bucketsNs = _nss.makeTimeseriesBucketsNamespace();
-        auto bucketsPlacementInfo = createDatabaseAndGetRoutingInfo(bucketsNs);
-        if (bucketsPlacementInfo.isSharded()) {
+        if (refresh) {
+            uassertStatusOK(Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfoWithRefresh(
+                opCtx, bucketsNs));
+        }
+        auto bucketsRoutingInfo =
+            uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, bucketsNs));
+        if (bucketsRoutingInfo.isSharded()) {
             _nss = bucketsNs;
-            cm = std::move(bucketsPlacementInfo);
+            cm = std::move(bucketsRoutingInfo);
             _isRequestOnTimeseriesViewNamespace = true;
         }
     } else if (!cm.isSharded() && _isRequestOnTimeseriesViewNamespace) {
         // This can happen if a sharded time-series collection is dropped and re-created. Then we
         // need to reset the namepace to the original namespace.
         _nss = _nss.getTimeseriesViewNamespace();
-        auto newCm = createDatabaseAndGetRoutingInfo(_nss);
-        cm = std::move(newCm);
+
+        if (refresh) {
+            uassertStatusOK(
+                Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfoWithRefresh(opCtx, _nss));
+        }
+        cm = uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, _nss));
         _isRequestOnTimeseriesViewNamespace = false;
     }
 
@@ -352,7 +323,7 @@ BSONObj ChunkManagerTargeter::extractBucketsShardKeyFromTimeseriesDoc(
 
     if (auto metaField = timeseriesOptions.getMetaField(); metaField) {
         if (auto metaElement = doc.getField(*metaField); !metaElement.eoo()) {
-            timeseries::metadata::normalize(metaElement, builder, timeseries::kBucketMetaFieldName);
+            builder.appendAs(metaElement, timeseries::kBucketMetaFieldName);
         }
     }
 
@@ -415,10 +386,6 @@ std::vector<ShardEndpoint> ChunkManagerTargeter::targetUpdate(OperationContext*
 
     const auto& updateOp = itemRef.getUpdate();
 
-    if (updateOp.getMulti()) {
-        updateManyCount.increment(1);
-    }
-
     // If the collection is not sharded, forward the update to the primary shard.
     if (!_cm.isSharded()) {
         // TODO (SERVER-51070): Remove the boost::none when the config server can support
@@ -535,11 +502,8 @@ std::vector<ShardEndpoint> ChunkManagerTargeter::targetDelete(OperationContext*
                                                                itemRef.getLet(),
                                                                itemRef.getLegacyRuntimeConstants());
 
-    if (deleteOp.getMulti()) {
-        deleteManyCount.increment(1);
-    }
-
     BSONObj deleteQuery = deleteOp.getQ();
+    BSONObj shardKey;
     if (_cm.isSharded()) {
         if (_isRequestOnTimeseriesViewNamespace) {
             uassert(ErrorCodes::NotImplemented,
@@ -565,13 +529,20 @@ std::vector<ShardEndpoint> ChunkManagerTargeter::targetDelete(OperationContext*
                 deleteQuery = BSONObj();
             }
         }
+
+        // Sharded collections have the following further requirements for targeting:
+        //
+        // Limit-1 deletes must be targeted exactly by shard key *or* exact _id
+        shardKey =
+            uassertStatusOK(_cm.getShardKeyPattern().extractShardKeyFromQuery(expCtx, deleteQuery));
     }
 
-    // We first try to target based on the delete's query. It is always valid to forward any delete
-    // to a single shard, so return immediately if we are able to target a single shard.
-    auto endpoints = uassertStatusOK(_targetQuery(expCtx, deleteQuery, collation));
-    if (endpoints.size() == 1) {
-        return endpoints;
+    // Target the shard key or delete query
+    if (!shardKey.isEmpty()) {
+        auto swEndpoint = _targetShardKey(shardKey, collation);
+        if (swEndpoint.isOK()) {
+            return std::vector{std::move(swEndpoint.getValue())};
+        }
     }
 
     // We failed to target a single shard.
@@ -600,7 +571,7 @@ std::vector<ShardEndpoint> ChunkManagerTargeter::targetDelete(OperationContext*
                           << ", shard key pattern: " << _cm.getShardKeyPattern().toString(),
             !_cm.isSharded() || deleteOp.getMulti() || isExactIdQuery(opCtx, *cq, _cm));
 
-    return endpoints;
+    return uassertStatusOK(_targetQuery(expCtx, deleteQuery, collation));
 }
 
 StatusWith<std::vector<ShardEndpoint>> ChunkManagerTargeter::_targetQuery(
diff --git a/src/mongo/s/chunk_manager_targeter.h b/src/mongo/s/chunk_manager_targeter.h
index 9de225a20a8..0950484eb7d 100644
--- a/src/mongo/s/chunk_manager_targeter.h
+++ b/src/mongo/s/chunk_manager_targeter.h
@@ -120,9 +120,6 @@ public:
         const TimeseriesOptions& timeseriesOptions);
 
 private:
-    // Maximum number of database creation attempts, which may fail due to a concurrent drop.
-    static const size_t kMaxDatabaseCreationAttempts;
-
     ChunkManager _init(OperationContext* opCtx, bool refresh);
 
     /**
diff --git a/src/mongo/s/chunk_manager_targeter_test.cpp b/src/mongo/s/chunk_manager_targeter_test.cpp
index f7e3642579e..14070303a0f 100644
--- a/src/mongo/s/chunk_manager_targeter_test.cpp
+++ b/src/mongo/s/chunk_manager_targeter_test.cpp
@@ -303,29 +303,22 @@ TEST_F(ChunkManagerTargeterTest, TargetDeleteWithRangePrefixHashedShardKey) {
                                          << "hashed"),
                               splitPoints);
 
-    // Can delete with partial shard key in the query if the query only targets one shard.
-    auto requestPartialKey = buildDelete(kNss, fromjson("{'a.b': {$gt : 101}}"));
-    auto res = cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestPartialKey, 0));
-    ASSERT_EQUALS(res.size(), 1);
-    ASSERT_EQUALS(res[0].shardName, "4");
-
-    // Cannot delete with partial shard key in the query if the query targets multiple shards.
-    auto requestPartialKey2 = buildDelete(kNss, fromjson("{'a.b': {$gt: 0}}"));
+    // Cannot delete without full shardkey in the query.
+    auto requestPartialKey = buildDelete(kNss, fromjson("{'a.b': {$gt : 2}}"));
     ASSERT_THROWS_CODE(
-        cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestPartialKey2, 0)),
+        cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestPartialKey, 0)),
         DBException,
         ErrorCodes::ShardKeyNotFound);
 
-    // Cannot delete without at least a partial shard key.
-    auto requestNoShardKey = buildDelete(kNss, fromjson("{'k': 0}"));
+    auto requestPartialKey2 = buildDelete(kNss, fromjson("{'a.b': -101}"));
     ASSERT_THROWS_CODE(
-        cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestNoShardKey, 0)),
+        cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestPartialKey2, 0)),
         DBException,
         ErrorCodes::ShardKeyNotFound);
 
     // Delete targeted correctly with full shard key in query.
     auto requestFullKey = buildDelete(kNss, fromjson("{'a.b': -101, 'c.d': 5}"));
-    res = cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestFullKey, 0));
+    auto res = cmTargeter.targetDelete(operationContext(), BatchItemRef(&requestFullKey, 0));
     ASSERT_EQUALS(res.size(), 1);
     ASSERT_EQUALS(res[0].shardName, "1");
 
diff --git a/src/mongo/s/chunk_map_test.cpp b/src/mongo/s/chunk_map_test.cpp
index 78b2ca42097..6514fc00745 100644
--- a/src/mongo/s/chunk_map_test.cpp
+++ b/src/mongo/s/chunk_map_test.cpp
@@ -27,104 +27,18 @@
  *    it in the license file.
  */
 
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kTest
-
 #include "mongo/platform/basic.h"
 
-#include "mongo/logv2/log.h"
-#include "mongo/platform/random.h"
 #include "mongo/s/chunk_manager.h"
-#include "mongo/s/chunk_writes_tracker.h"
-#include "mongo/s/chunks_test_util.h"
 #include "mongo/unittest/unittest.h"
 
 namespace mongo {
 
-using chunks_test_util::assertEqualChunkInfo;
-using chunks_test_util::calculateCollVersion;
-using chunks_test_util::calculateIntermediateShardKey;
-using chunks_test_util::genChunkVector;
-using chunks_test_util::genRandomSplitPoints;
-using chunks_test_util::performRandomChunkOperations;
-
 namespace {
 
-PseudoRandom _random{SecureRandom().nextInt64()};
-
+const NamespaceString kNss("TestDB", "TestColl");
 const ShardId kThisShard("testShard");
 
-ShardVersionMap getShardVersionMap(const ChunkMap& chunkMap) {
-    return chunkMap.getShardVersionsMap();
-}
-
-std::map<ShardId, ChunkVersion> calculateShardVersions(
-    const std::vector<std::shared_ptr<ChunkInfo>>& chunkVector) {
-    std::map<ShardId, ChunkVersion> svMap;
-    for (const auto& chunk : chunkVector) {
-        auto mapIt = svMap.find(chunk->getShardId());
-        if (mapIt == svMap.end()) {
-            svMap.emplace(chunk->getShardId(), chunk->getLastmod());
-            continue;
-        }
-        if (mapIt->second.isOlderThan(chunk->getLastmod())) {
-            mapIt->second = chunk->getLastmod();
-        }
-    }
-    return svMap;
-}
-
-std::vector<std::shared_ptr<ChunkInfo>> toChunkInfoPtrVector(
-    const std::vector<ChunkType>& chunkTypes, bool initializeWriteTrackerRandom = true) {
-    std::vector<std::shared_ptr<ChunkInfo>> chunkPtrs;
-    chunkPtrs.reserve(chunkTypes.size());
-    for (const auto& chunkType : chunkTypes) {
-        auto chunkInfoPtr = std::make_shared<ChunkInfo>(chunkType);
-        if (initializeWriteTrackerRandom) {
-            chunkInfoPtr->getWritesTracker()->addBytesWritten(_random.nextInt64(30));
-        }
-        chunkPtrs.push_back(std::move(chunkInfoPtr));
-    }
-    return chunkPtrs;
-}
-
-void validateChunkMap(const ChunkMap& chunkMap,
-                      const std::vector<std::shared_ptr<ChunkInfo>>& chunkInfoVector) {
-
-    // The chunkMap should contain all the chunks
-    ASSERT_EQ(chunkInfoVector.size(), chunkMap.size());
-
-    // Check collection version
-    const auto expectedShardVersions = calculateShardVersions(chunkInfoVector);
-    const auto expectedCollVersion = calculateCollVersion(expectedShardVersions);
-    ASSERT_EQ(expectedCollVersion, chunkMap.getVersion());
-
-    size_t i = 0;
-    chunkMap.forEach([&](const auto& chunkPtr) {
-        const auto& expectedChunkPtr = chunkInfoVector[i++];
-        // Check that the chunk pointer is valid
-        ASSERT(chunkPtr.get() != nullptr);
-        assertEqualChunkInfo(*expectedChunkPtr, *chunkPtr);
-        return true;
-    });
-
-    // Validate all shard versions
-    const auto shardVersions = getShardVersionMap(chunkMap);
-    ASSERT_EQ(expectedShardVersions.size(), shardVersions.size());
-    for (const auto& mapIt : shardVersions) {
-        ASSERT_EQ(expectedShardVersions.at(mapIt.first), mapIt.second.shardVersion);
-    }
-
-    // Check that vectors are balanced in size
-    auto maxVectorSize = static_cast<size_t>(std::lround(chunkMap.getMaxChunkVectorSize() * 1.5));
-    auto minVectorSize = std::min(
-        chunkMap.size(), static_cast<size_t>(std::lround(chunkMap.getMaxChunkVectorSize() / 2)));
-
-    for (const auto& [maxKeyString, chunkVectorPtr] : chunkMap.getChunkVectorMap()) {
-        ASSERT_GTE(chunkVectorPtr->size(), minVectorSize);
-        ASSERT_LTE(chunkVectorPtr->size(), maxVectorSize);
-    }
-}
-
 class ChunkMapTest : public unittest::Test {
 public:
     const KeyPattern& getShardKeyPattern() const {
@@ -135,36 +49,16 @@ public:
         return _uuid;
     }
 
-    const OID& collEpoch() const {
-        return _epoch;
-    }
-
-    const Timestamp& collTimestamp() const {
-        return _collTimestamp;
-    }
-
-    ChunkMap makeChunkMap(const std::vector<std::shared_ptr<ChunkInfo>>& chunks) const {
-        const auto chunkBucketSize =
-            static_cast<size_t>(_random.nextInt64(chunks.size() * 1.2) + 1);
-        LOGV2(7162701, "Creating new chunk map", "chunkBucketSize"_attr = chunkBucketSize);
-        return ChunkMap{collEpoch(), collTimestamp(), chunkBucketSize}.createMerged(chunks);
-    }
-
-    std::vector<ChunkType> genRandomChunkVector(size_t maxNumChunks = 30,
-                                                size_t minNumChunks = 1) const {
-        return chunks_test_util::genRandomChunkVector(
-            _uuid, _epoch, _collTimestamp, maxNumChunks, minNumChunks);
-    }
-
 private:
-    KeyPattern _shardKeyPattern{chunks_test_util::kShardKeyPattern};
+    KeyPattern _shardKeyPattern{BSON("a" << 1)};
     const UUID _uuid = UUID::gen();
-    const OID _epoch{OID::gen()};
-    const Timestamp _collTimestamp{1, 1};
 };
 
+}  // namespace
+
 TEST_F(ChunkMapTest, TestAddChunk) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
+    const OID epoch = OID::gen();
+    ChunkVersion version{1, 0, epoch, Timestamp(1, 1)};
 
     auto chunk = std::make_shared<ChunkInfo>(
         ChunkType{uuid(),
@@ -172,190 +66,18 @@ TEST_F(ChunkMapTest, TestAddChunk) {
                   version,
                   kThisShard});
 
-    auto newChunkMap = makeChunkMap({chunk});
+    ChunkMap chunkMap{epoch, Timestamp(1, 1)};
+    auto newChunkMap = chunkMap.createMerged({chunk});
 
     ASSERT_EQ(newChunkMap.size(), 1);
-
-    validateChunkMap(newChunkMap, {chunk});
-}
-
-TEST_F(ChunkMapTest, ConstructChunkMapRandom) {
-    auto chunkVector = toChunkInfoPtrVector(genRandomChunkVector());
-
-    const auto chunkMap = makeChunkMap(chunkVector);
-
-    validateChunkMap(chunkMap, chunkVector);
-}
-
-TEST_F(ChunkMapTest, ConstructChunkMapRandomAllChunksSameVersion) {
-    auto chunkVector = genRandomChunkVector();
-    auto commonVersion = chunkVector.front().getVersion();
-
-    // Set same version on all chunks
-    for (auto& chunk : chunkVector) {
-        chunk.setVersion(commonVersion);
-    }
-
-    auto chunkInfoVector = toChunkInfoPtrVector(chunkVector);
-    const auto expectedShardVersions = calculateShardVersions(chunkInfoVector);
-    const auto expectedCollVersion = calculateCollVersion(expectedShardVersions);
-
-    ASSERT_EQ(commonVersion, expectedCollVersion);
-
-    const auto chunkMap = makeChunkMap(chunkInfoVector);
-    validateChunkMap(chunkMap, chunkInfoVector);
-}
-
-/*
- * Check that constucting a ChunkMap with chunks that have mismatching timestamp fails.
- */
-TEST_F(ChunkMapTest, ConstructChunkMapMismatchingTimestamp) {
-    auto chunkVector = toChunkInfoPtrVector(genRandomChunkVector());
-
-    // Set a different epoch in one of the chunks
-    const Timestamp wrongTimestamp{Date_t::now()};
-    ASSERT_NE(wrongTimestamp, collTimestamp());
-    const auto wrongChunkIdx = _random.nextInt32(chunkVector.size());
-    const auto oldChunk = chunkVector.at(wrongChunkIdx);
-    const auto oldVersion = oldChunk->getLastmod();
-    const ChunkVersion wrongVersion{
-        oldVersion.majorVersion(), oldVersion.minorVersion(), collEpoch(), wrongTimestamp};
-    chunkVector[wrongChunkIdx] = std::make_shared<ChunkInfo>(
-        ChunkType{uuid(), oldChunk->getRange(), wrongVersion, oldChunk->getShardId()});
-
-    ASSERT_THROWS_CODE(
-        makeChunkMap(chunkVector), AssertionException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-TEST_F(ChunkMapTest, UpdateMapNotLeaveSmallVectors) {
-    const ChunkVersion initialVersion{1, 0, collEpoch(), collTimestamp()};
-    auto chunkVector = toChunkInfoPtrVector(
-        genChunkVector(uuid(), genRandomSplitPoints(8), initialVersion, 1 /*numShards*/));
-
-    const auto chunkBucketSize = 4;
-    LOGV2(7162703, "Constructing new chunk map", "chunkBucketSize"_attr = chunkBucketSize);
-    const auto initialChunkMap =
-        ChunkMap(collEpoch(), collTimestamp(), chunkBucketSize).createMerged(chunkVector);
-
-    // Check that it contains all the chunks
-    ASSERT_EQ(chunkVector.size(), initialChunkMap.size());
-
-    auto mergedVersion = initialChunkMap.getVersion();
-    mergedVersion.incMinor();
-
-    auto mergedChunk = std::make_shared<ChunkInfo>(ChunkType{
-        uuid(),
-        ChunkRange{chunkVector[4]->getRange().getMin(), chunkVector.back()->getRange().getMax()},
-        mergedVersion,
-        kThisShard});
-    const auto chunkMap = initialChunkMap.createMerged({mergedChunk});
-
-    // Check that vectors are balanced in size
-    auto maxVectorSize = std::lround(chunkMap.getMaxChunkVectorSize() * 1.5);
-    auto minVectorSize = std::min(
-        chunkMap.size(), static_cast<size_t>(std::lround(chunkMap.getMaxChunkVectorSize() / 2)));
-
-    for (const auto& [maxKeyString, chunkVectorPtr] : chunkMap.getChunkVectorMap()) {
-        ASSERT_GTE(chunkVectorPtr->size(), minVectorSize);
-        ASSERT_LTE(chunkVectorPtr->size(), maxVectorSize);
-    }
-
-    // Check original map is sitll valid
-    validateChunkMap(initialChunkMap, chunkVector);
-}
-
-
-/*
- * Check that updating a ChunkMap with chunks that have mismatching timestamp fails.
- */
-TEST_F(ChunkMapTest, UpdateChunkMapMismatchingTimestamp) {
-    auto chunkVector = toChunkInfoPtrVector(genRandomChunkVector());
-
-    auto chunkMap = makeChunkMap(chunkVector);
-    auto collVersion = chunkMap.getVersion();
-
-    // Set a different epoch in one of the chunks
-    const Timestamp wrongTimestamp{Date_t::now()};
-    const auto wrongChunkIdx = _random.nextInt32(chunkVector.size());
-    const auto oldChunk = chunkVector.at(wrongChunkIdx);
-    const ChunkVersion wrongVersion{
-        collVersion.majorVersion(), collVersion.minorVersion(), collEpoch(), wrongTimestamp};
-    auto updateChunk = std::make_shared<ChunkInfo>(
-        ChunkType{uuid(), oldChunk->getRange(), wrongVersion, oldChunk->getShardId()});
-
-    ASSERT_THROWS_CODE(chunkMap.createMerged({updateChunk}),
-                       AssertionException,
-                       ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Check that updating a ChunkMap with chunks that have lower version fails.
- */
-TEST_F(ChunkMapTest, UpdateChunkMapLowerVersion) {
-    auto chunkVector = toChunkInfoPtrVector(genRandomChunkVector());
-
-    auto chunkMap = makeChunkMap(chunkVector);
-
-    const auto wrongChunkIdx = _random.nextInt32(chunkVector.size());
-    const auto oldChunk = chunkVector.at(wrongChunkIdx);
-    const ChunkVersion wrongVersion{0, 1, collEpoch(), collTimestamp()};
-    auto updateChunk = std::make_shared<ChunkInfo>(
-        ChunkType{uuid(), oldChunk->getRange(), wrongVersion, oldChunk->getShardId()});
-
-    ASSERT_THROWS_CODE(chunkMap.createMerged({updateChunk}), AssertionException, 626840);
-}
-/*
- * Test update of ChunkMap with random chunk manipulation (splits/merges/moves);
- */
-TEST_F(ChunkMapTest, UpdateChunkMapRandom) {
-    auto initialChunks = genRandomChunkVector();
-    auto initialChunksInfo = toChunkInfoPtrVector(initialChunks);
-
-    const auto initialChunkMap = makeChunkMap(initialChunksInfo);
-
-    const auto initialShardVersions = calculateShardVersions(initialChunksInfo);
-    const auto initialCollVersion = calculateCollVersion(initialShardVersions);
-
-    auto chunks = initialChunks;
-
-    const auto maxNumChunkOps = 2 * initialChunks.size();
-    const auto numChunkOps = _random.nextInt32(maxNumChunkOps);
-    performRandomChunkOperations(&chunks, numChunkOps);
-
-    auto chunksInfo = toChunkInfoPtrVector(initialChunks, false /* initializeWriteTrackerRandom */);
-
-    std::vector<std::shared_ptr<ChunkInfo>> updatedChunksInfo;
-    for (auto& chunkPtr : chunksInfo) {
-        // First overlapping chunk in the initial vector
-        const auto& overlapInitChunk =
-            **std::lower_bound(initialChunksInfo.begin(),
-                               initialChunksInfo.end(),
-                               ShardKeyPattern::toKeyString(chunkPtr->getRange().getMin()),
-                               [](const auto& chunkInfo, const std::string& shardKeyString) {
-                                   return chunkInfo->getMaxKeyString() <= shardKeyString;
-                               });
-        // The new chunks inherits the written bytes from the first overlapping old chunk
-        chunkPtr->getWritesTracker()->addBytesWritten(
-            overlapInitChunk.getWritesTracker()->getBytesWritten());
-
-        if (!chunkPtr->getLastmod().isOlderOrEqualThan(initialCollVersion)) {
-            updatedChunksInfo.push_back(std::make_shared<ChunkInfo>(ChunkType{
-                uuid(), chunkPtr->getRange(), chunkPtr->getLastmod(), chunkPtr->getShardId()}));
-        }
-    }
-
-    // Create updated chunk map and validate it
-    auto chunkMap = initialChunkMap.createMerged(updatedChunksInfo);
-    validateChunkMap(chunkMap, chunksInfo);
-
-    // Check that the initialChunkMap is still valid and usable
-    validateChunkMap(initialChunkMap, initialChunksInfo);
 }
 
 TEST_F(ChunkMapTest, TestEnumerateAllChunks) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
+    const OID epoch = OID::gen();
+    ChunkMap chunkMap{epoch, Timestamp(1, 1)};
+    ChunkVersion version{1, 0, epoch, Timestamp(1, 1)};
 
-    auto newChunkMap = makeChunkMap(
+    auto newChunkMap = chunkMap.createMerged(
         {std::make_shared<ChunkInfo>(
              ChunkType{uuid(),
                        ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
@@ -385,11 +107,12 @@ TEST_F(ChunkMapTest, TestEnumerateAllChunks) {
     ASSERT_EQ(count, newChunkMap.size());
 }
 
-
 TEST_F(ChunkMapTest, TestIntersectingChunk) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
+    const OID epoch = OID::gen();
+    ChunkMap chunkMap{epoch, Timestamp(1, 1)};
+    ChunkVersion version{1, 0, epoch, Timestamp(1, 1)};
 
-    auto newChunkMap = makeChunkMap(
+    auto newChunkMap = chunkMap.createMerged(
         {std::make_shared<ChunkInfo>(
              ChunkType{uuid(),
                        ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
@@ -412,33 +135,14 @@ TEST_F(ChunkMapTest, TestIntersectingChunk) {
         SimpleBSONObjComparator::kInstance.evaluate(intersectingChunk->getMin() == BSON("a" << 0)));
     ASSERT(SimpleBSONObjComparator::kInstance.evaluate(intersectingChunk->getMax() ==
                                                        BSON("a" << 100)));
-
-    // findIntersectingChunks returns last chunk if invoked with MaxKey
-    intersectingChunk =
-        newChunkMap.findIntersectingChunk(BSON("a" << getShardKeyPattern().globalMax()));
-    ASSERT(SimpleBSONObjComparator::kInstance.evaluate(intersectingChunk->getMin() ==
-                                                       BSON("a" << 100)));
-    ASSERT(SimpleBSONObjComparator::kInstance.evaluate(intersectingChunk->getMax() ==
-                                                       getShardKeyPattern().globalMax()));
-}
-
-TEST_F(ChunkMapTest, TestIntersectingChunkRandom) {
-    auto chunks = toChunkInfoPtrVector(genRandomChunkVector());
-
-    const auto chunkMap = makeChunkMap(chunks);
-
-    auto targetChunkIt = chunks.begin() + _random.nextInt64(chunks.size());
-    auto intermediateKey = calculateIntermediateShardKey(
-        (*targetChunkIt)->getMin(), (*targetChunkIt)->getMax(), 0.2 /* minKeyProb */);
-
-    auto intersectingChunkPtr = chunkMap.findIntersectingChunk(intermediateKey);
-    assertEqualChunkInfo(**(targetChunkIt), *intersectingChunkPtr);
 }
 
 TEST_F(ChunkMapTest, TestEnumerateOverlappingChunks) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
+    const OID epoch = OID::gen();
+    ChunkMap chunkMap{epoch, Timestamp(1, 1)};
+    ChunkVersion version{1, 0, epoch, Timestamp(1, 1)};
 
-    auto newChunkMap = makeChunkMap(
+    auto newChunkMap = chunkMap.createMerged(
         {std::make_shared<ChunkInfo>(
              ChunkType{uuid(),
                        ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
@@ -456,101 +160,14 @@ TEST_F(ChunkMapTest, TestEnumerateOverlappingChunks) {
 
     auto min = BSON("a" << -50);
     auto max = BSON("a" << 150);
+
     int count = 0;
     newChunkMap.forEachOverlappingChunk(min, max, true, [&](const auto& chunk) {
         count++;
         return true;
     });
-    ASSERT_EQ(count, 3);
 
-    min = BSON("a" << -50);
-    max = BSON("a" << getShardKeyPattern().globalMax());
-    count = 0;
-    newChunkMap.forEachOverlappingChunk(min, max, false, [&](const auto& chunk) {
-        count++;
-        return true;
-    });
     ASSERT_EQ(count, 3);
-
-    min = BSON("a" << 50);
-    max = BSON("a" << 100);
-    count = 0;
-    newChunkMap.forEachOverlappingChunk(min, max, true, [&](const auto& chunk) {
-        count++;
-        return true;
-    });
-    ASSERT_EQ(count, 2);
-
-    min = BSON("a" << 50);
-    max = BSON("a" << 100);
-    count = 0;
-    newChunkMap.forEachOverlappingChunk(min, max, false, [&](const auto& chunk) {
-        count++;
-        return true;
-    });
-    ASSERT_EQ(count, 1);
-}
-
-TEST_F(ChunkMapTest, ForEachNoShardKey) {
-    auto chunks = toChunkInfoPtrVector(genRandomChunkVector());
-
-    const auto chunkMap = makeChunkMap(chunks);
-
-    auto lastChunkIdx = std::max(_random.nextInt64(chunks.size()), static_cast<int64_t>(1));
-
-    int i = 0;
-    chunkMap.forEach([&](const auto& chunkInfo) {
-        assertEqualChunkInfo(*chunks[i], *chunkInfo);
-        return ++i < lastChunkIdx;
-    });
-
-    ASSERT_EQ(i, lastChunkIdx);
-}
-
-TEST_F(ChunkMapTest, ForEachWithShardKey) {
-    auto chunks = toChunkInfoPtrVector(genRandomChunkVector());
-
-    const auto chunkMap = makeChunkMap(chunks);
-
-    auto firstChunkIdx = static_cast<size_t>(_random.nextInt64(chunks.size()));
-    const auto& firstChunk = chunks[firstChunkIdx];
-    auto skey = calculateIntermediateShardKey(
-        firstChunk->getMin(), firstChunk->getMax(), 0.2 /* minKeyProb */);
-
-    size_t i = firstChunkIdx;
-    auto lastChunkIdx = firstChunkIdx +
-        std::max(_random.nextInt64(chunks.size() - firstChunkIdx), static_cast<int64_t>(1));
-    chunkMap.forEach(
-        [&](const auto& chunkInfo) {
-            assertEqualChunkInfo(*chunks[i], *chunkInfo);
-            return ++i < lastChunkIdx;
-        },
-        skey);
-
-    ASSERT_EQ(i, lastChunkIdx);
-}
-
-TEST_F(ChunkMapTest, TestEnumerateOverlappingChunksRandom) {
-    auto chunks = toChunkInfoPtrVector(genRandomChunkVector());
-
-    const auto chunkMap = makeChunkMap(chunks);
-
-    auto firstChunkIt = chunks.begin() + _random.nextInt64(chunks.size());
-    auto lastChunkIt = firstChunkIt + _random.nextInt64(std::distance(firstChunkIt, chunks.end()));
-
-    auto minBound = calculateIntermediateShardKey(
-        (*firstChunkIt)->getMin(), (*firstChunkIt)->getMax(), 0.2 /* minKeyProb */);
-    auto maxBound = calculateIntermediateShardKey(
-        (*lastChunkIt)->getMin(), (*lastChunkIt)->getMax(), 0.2 /* minKeyProb */);
-
-    auto it = firstChunkIt;
-    chunkMap.forEachOverlappingChunk(minBound, maxBound, true, [&](const auto& chunkInfoPtr) {
-        assertEqualChunkInfo(**(it++), *chunkInfoPtr);
-        return true;
-    });
-    ASSERT_EQ(0, std::distance(it, std::next(lastChunkIt)));
 }
 
-}  // namespace
-
 }  // namespace mongo
diff --git a/src/mongo/s/chunks_test_util.cpp b/src/mongo/s/chunks_test_util.cpp
deleted file mode 100644
index 4c410ed260a..00000000000
--- a/src/mongo/s/chunks_test_util.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-/**
- *    Copyright (C) 2023-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kTest
-
-#include "mongo/s/chunks_test_util.h"
-#include "mongo/db/namespace_string.h"
-#include "mongo/logv2/log.h"
-#include "mongo/platform/random.h"
-#include "mongo/s/shard_key_pattern.h"
-#include "mongo/unittest/unittest.h"
-
-namespace mongo::chunks_test_util {
-namespace {
-
-PseudoRandom _random{SecureRandom().nextInt64()};
-
-std::vector<ChunkHistory> genChunkHistory(const ShardId& currentShard,
-                                          const Timestamp& onCurrentShardSince,
-                                          size_t numShards,
-                                          size_t maxLenght) {
-    std::vector<ChunkHistory> history;
-    const auto historyLength = _random.nextInt64(maxLenght);
-    auto lastTime = onCurrentShardSince;
-    for (int64_t i = 0; i < historyLength; i++) {
-        auto shard = i == 0 ? currentShard : getShardId(_random.nextInt64(numShards));
-        history.emplace_back(onCurrentShardSince, shard);
-        lastTime = lastTime - 1 - _random.nextInt64(10000);
-    }
-    return history;
-}
-
-}  // namespace
-
-void assertEqualChunkInfo(const ChunkInfo& x, const ChunkInfo& y) {
-    ASSERT_BSONOBJ_EQ(x.getMin(), y.getMin());
-    ASSERT_BSONOBJ_EQ(x.getMax(), y.getMax());
-    ASSERT_EQ(x.getMaxKeyString(), y.getMaxKeyString());
-    ASSERT_EQ(x.getShardId(), y.getShardId());
-    ASSERT_EQ(x.getLastmod(), y.getLastmod());
-    ASSERT_EQ(x.isJumbo(), y.isJumbo());
-    ASSERT_EQ(x.getWritesTracker()->getBytesWritten(), y.getWritesTracker()->getBytesWritten());
-}
-
-ShardId getShardId(int shardIdx) {
-    return {std::string(str::stream() << "shard_" << shardIdx)};
-}
-
-std::vector<BSONObj> genRandomSplitPoints(size_t numChunks) {
-    std::vector<BSONObj> splitPoints;
-    splitPoints.reserve(numChunks + 1);
-    splitPoints.emplace_back(kShardKeyPattern.globalMin());
-    int64_t nextSplit{-1000};
-    for (size_t i = 0; i < numChunks - 1; ++i) {
-        nextSplit += 10 * (_random.nextInt32(10) + 1);
-        splitPoints.emplace_back(BSON(kSKey << nextSplit));
-    }
-    splitPoints.emplace_back(kShardKeyPattern.globalMax());
-    return splitPoints;
-}
-
-std::vector<ChunkVersion> genRandomVersions(size_t num, const ChunkVersion& initialVersion) {
-    std::vector<ChunkVersion> versions;
-    versions.reserve(num);
-    auto major = initialVersion.majorVersion();
-    auto minor = initialVersion.minorVersion();
-
-    for (size_t i = 0; i < num; ++i) {
-        if (_random.nextInt32(2)) {
-            ++major;
-            minor = 0;
-        } else {
-            ++minor;
-        }
-        versions.emplace_back(major, minor, initialVersion.epoch(), initialVersion.getTimestamp());
-    }
-    std::shuffle(versions.begin(), versions.end(), _random.urbg());
-    return versions;
-}
-
-std::vector<ChunkType> genChunkVector(const UUID& uuid,
-                                      const std::vector<BSONObj>& splitPoints,
-                                      const ChunkVersion& initialVersion,
-                                      size_t numShards) {
-
-    return genChunkVector(
-        uuid, splitPoints, genRandomVersions(splitPoints.size() - 1, initialVersion), numShards);
-}
-
-std::vector<ChunkType> genChunkVector(const UUID& uuid,
-                                      const std::vector<BSONObj>& splitPoints,
-                                      const std::vector<ChunkVersion>& versions,
-                                      size_t numShards) {
-
-    invariant(SimpleBSONObjComparator::kInstance.evaluate(splitPoints.front() ==
-                                                          kShardKeyPattern.globalMin()));
-    invariant(SimpleBSONObjComparator::kInstance.evaluate(splitPoints.back() ==
-                                                          kShardKeyPattern.globalMax()));
-    const auto numChunks = splitPoints.size() - 1;
-    invariant(numChunks == versions.size());
-
-    std::vector<ChunkType> chunks;
-    chunks.reserve(numChunks);
-    auto minKey = splitPoints.front();
-    for (size_t i = 0; i < numChunks; ++i) {
-        auto maxKey = splitPoints.at(i + 1);
-        const auto shard = getShardId(_random.nextInt64(numShards));
-        const auto version = versions.at(i);
-        ChunkType chunk{uuid, ChunkRange{minKey, maxKey}, version, shard};
-        chunk.setHistory(
-            genChunkHistory(shard, Timestamp{Date_t::now()}, numShards, 10 /* maxLenght */));
-        chunks.emplace_back(std::move(chunk));
-        minKey = std::move(maxKey);
-    }
-    return chunks;
-}
-
-std::map<ShardId, Timestamp> calculateShardsMaxValidAfter(
-    const std::vector<ChunkType>& chunkVector) {
-
-    std::map<ShardId, Timestamp> vaMap;
-    for (const auto& chunk : chunkVector) {
-        if (chunk.getHistory().empty())
-            continue;
-
-        const auto& chunkMaxValidAfter = chunk.getHistory().front().getValidAfter();
-        auto mapIt = vaMap.find(chunk.getShard());
-        if (mapIt == vaMap.end()) {
-            vaMap.emplace(chunk.getShard(), chunkMaxValidAfter);
-            continue;
-        }
-        if (chunkMaxValidAfter > mapIt->second) {
-            mapIt->second = chunkMaxValidAfter;
-        }
-    }
-    return vaMap;
-}
-
-ChunkVersion calculateCollVersion(const std::map<ShardId, ChunkVersion>& shardVersions) {
-    return std::max_element(shardVersions.begin(),
-                            shardVersions.end(),
-                            [](const std::pair<ShardId, ChunkVersion>& p1,
-                               const std::pair<ShardId, ChunkVersion>& p2) {
-                                return p1.second.isOlderThan(p2.second);
-                            })
-        ->second;
-}
-
-std::map<ShardId, ChunkVersion> calculateShardVersions(const std::vector<ChunkType>& chunkVector) {
-    std::map<ShardId, ChunkVersion> svMap;
-    for (const auto& chunk : chunkVector) {
-        auto mapIt = svMap.find(chunk.getShard());
-        if (mapIt == svMap.end()) {
-            svMap.emplace(chunk.getShard(), chunk.getVersion());
-            continue;
-        }
-        if (mapIt->second.isOlderThan(chunk.getVersion())) {
-            mapIt->second = chunk.getVersion();
-        }
-    }
-    return svMap;
-}
-
-std::vector<ChunkType> genRandomChunkVector(const UUID& uuid,
-                                            const OID& epoch,
-                                            const Timestamp& timestamp,
-                                            size_t maxNumChunks,
-                                            size_t minNumChunks) {
-    invariant(minNumChunks <= maxNumChunks);
-    const auto numChunks = minNumChunks + _random.nextInt32((maxNumChunks - minNumChunks) + 1);
-    const auto numShards = _random.nextInt32(numChunks) + 1;
-    const ChunkVersion initialVersion{1, 0, epoch, timestamp};
-
-    LOGV2(7162700,
-          "Generating random chunk vector",
-          "numChunks"_attr = numChunks,
-          "numShards"_attr = numShards);
-
-    return genChunkVector(uuid, genRandomSplitPoints(numChunks), initialVersion, numShards);
-}
-
-BSONObj calculateIntermediateShardKey(const BSONObj& leftKey,
-                                      const BSONObj& rightKey,
-                                      double minKeyProb,
-                                      double maxKeyProb) {
-    invariant(0 <= minKeyProb && minKeyProb <= 1, "minKeyProb out of range [0, 1]");
-    invariant(0 <= maxKeyProb && maxKeyProb <= 1, "maxKeyProb out of range [0, 1]");
-
-    if (_random.nextInt32(100) < minKeyProb * 100) {
-        return leftKey;
-    }
-
-    if (_random.nextInt32(100) < maxKeyProb * 100) {
-        return rightKey;
-    }
-
-    const auto isMinKey = leftKey.woCompare(kShardKeyPattern.globalMin()) == 0;
-    const auto isMaxKey = rightKey.woCompare(kShardKeyPattern.globalMax()) == 0;
-
-    int64_t splitPoint;
-    if (isMinKey && isMaxKey) {
-        // [min, max] -> split at 0
-        splitPoint = 0;
-    } else if (!isMinKey && !isMaxKey) {
-        // [x, y] -> split in the middle
-        auto min = leftKey.firstElement().numberLong();
-        auto max = rightKey.firstElement().numberLong();
-        invariant(min + 1 < max,
-                  str::stream() << "Can't split range [" << min << ", " << max << "]");
-        splitPoint = min + ((max - min) / 2);
-    } else if (isMaxKey) {
-        // [x, maxKey] -> split at x*2;
-        auto prevBound = leftKey.firstElement().numberLong();
-        auto increment = prevBound ? prevBound : _random.nextInt32(100) + 1;
-        splitPoint = prevBound + std::abs(increment);
-    } else if (isMinKey) {
-        // [minKey, x] -> split at x*2;
-        auto prevBound = rightKey.firstElement().numberLong();
-        auto increment = prevBound ? prevBound : _random.nextInt32(100) + 1;
-        splitPoint = prevBound - std::abs(increment);
-    } else {
-        MONGO_UNREACHABLE;
-    }
-
-    return BSON(kSKey << splitPoint);
-}
-
-void performRandomChunkOperations(std::vector<ChunkType>* chunksPtr, size_t numOperations) {
-    auto& chunks = *chunksPtr;
-    auto collVersion = calculateCollVersion(calculateShardVersions(chunks));
-
-    auto moveChunk = [&] {
-        auto& chunkToMigrate = chunks[_random.nextInt32(chunks.size())];
-        collVersion.incMajor();
-
-        auto controlChunkIt = std::find_if(chunks.begin(), chunks.end(), [&](const auto& chunk) {
-            return chunk.getShard() == chunkToMigrate.getShard() &&
-                !chunk.getRange().overlaps(chunkToMigrate.getRange());
-        });
-        if (controlChunkIt != chunks.end()) {
-            controlChunkIt->setVersion(collVersion);
-            collVersion.incMinor();
-        }
-        auto newShard = getShardId(_random.nextInt64(chunks.size()));
-        chunkToMigrate.setShard(newShard);
-        chunkToMigrate.setVersion(collVersion);
-        chunkToMigrate.setHistory([&] {
-            auto history = chunkToMigrate.getHistory();
-            history.emplace(history.begin(), Timestamp{Date_t::now()}, newShard);
-            return history;
-        }());
-    };
-
-    auto splitChunk = [&] {
-        auto chunkToSplitIt = chunks.begin() + _random.nextInt32(chunks.size());
-        while (chunkToSplitIt != chunks.begin() && chunkToSplitIt != std::prev(chunks.end()) &&
-               (chunkToSplitIt->getMax().firstElement().numberLong() -
-                chunkToSplitIt->getMin().firstElement().numberLong()) < 2) {
-            // If the chunk is unsplittable select another one
-            chunkToSplitIt = chunks.begin() + _random.nextInt32(chunks.size());
-        }
-
-        const auto& chunkToSplit = *chunkToSplitIt;
-
-        auto splitKey = calculateIntermediateShardKey(chunkToSplit.getMin(), chunkToSplit.getMax());
-
-        collVersion.incMinor();
-        const ChunkRange leftRange{chunkToSplit.getMin(), splitKey};
-        ChunkType leftChunk{
-            chunkToSplit.getCollectionUUID(), leftRange, collVersion, chunkToSplit.getShard()};
-        leftChunk.setHistory(chunkToSplit.getHistory());
-
-        collVersion.incMinor();
-        const ChunkRange rightRange{splitKey, chunkToSplit.getMax()};
-        ChunkType rightChunk{
-            chunkToSplit.getCollectionUUID(), rightRange, collVersion, chunkToSplit.getShard()};
-        rightChunk.setHistory(chunkToSplit.getHistory());
-
-        auto it = chunks.erase(chunkToSplitIt);
-        it = chunks.insert(it, std::move(rightChunk));
-        it = chunks.insert(it, std::move(leftChunk));
-    };
-
-    auto mergeChunks = [&] {
-        const auto firstChunkIt = chunks.begin() + _random.nextInt32(chunks.size());
-        const auto& shardId = firstChunkIt->getShard();
-        auto lastChunkIt = std::find_if(firstChunkIt, chunks.end(), [&](const auto& chunk) {
-            return chunk.getShard() != shardId;
-        });
-        const auto numContiguosChunks = std::distance(firstChunkIt, lastChunkIt);
-        if (numContiguosChunks < 2) {
-            // nothing to merge
-            return;
-        }
-        const auto numChunkToMerge = _random.nextInt32(numContiguosChunks - 1) + 2;
-        lastChunkIt = firstChunkIt + numChunkToMerge;
-        const auto& firstChunk = *firstChunkIt;
-        collVersion.incMinor();
-        const ChunkRange mergedRange{firstChunk.getMin(), std::prev(lastChunkIt)->getMax()};
-        ChunkType mergedChunk{
-            firstChunk.getCollectionUUID(), mergedRange, collVersion, firstChunk.getShard()};
-        mergedChunk.setHistory({ChunkHistory{Timestamp{Date_t::now()}, firstChunk.getShard()}});
-
-        auto it = chunks.erase(firstChunkIt, lastChunkIt);
-        it = chunks.insert(it, mergedChunk);
-    };
-
-    for (size_t i = 0; i < numOperations; i++) {
-        switch (_random.nextInt32(3)) {
-            case 0:
-                moveChunk();
-                break;
-            case 1:
-                splitChunk();
-                break;
-            case 2:
-                mergeChunks();
-                break;
-            default:
-                MONGO_UNREACHABLE;
-                break;
-        }
-    }
-}
-
-}  // namespace mongo::chunks_test_util
diff --git a/src/mongo/s/chunks_test_util.h b/src/mongo/s/chunks_test_util.h
deleted file mode 100644
index b271939caa5..00000000000
--- a/src/mongo/s/chunks_test_util.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- *    Copyright (C) 2023-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#include "mongo/platform/basic.h"
-
-#include "mongo/s/chunk.h"
-#include "mongo/s/chunk_writes_tracker.h"
-
-namespace mongo::chunks_test_util {
-
-static const std::string kSKey{"a"};
-static const KeyPattern kShardKeyPattern{BSON(kSKey << 1)};
-
-/*
- * Assert that all the fields contained in the provided ChunkInfo are equal.
- *
- * This is needed since ChunkInfo class does not provide an equal operator.
- */
-void assertEqualChunkInfo(const ChunkInfo& x, const ChunkInfo& y);
-
-ShardId getShardId(int shardIdx);
-
-/**
- * Return a vector of randomly generated split points.
- * covering the entire shard key space including the boundaries [minKey, maxKey)
- *
- * e.g. {"a": <int>}
- */
-std::vector<BSONObj> genRandomSplitPoints(size_t numChunks);
-
-/*
- * Generate a shuffled list of random chunk versions.
- *
- * The generated versions are all strictly greater than the provided initialVersion.
- */
-std::vector<ChunkVersion> genRandomVersions(size_t num, const ChunkVersion& initialVersion);
-
-/*
- * Generate a vector of chunks whose boundaries are defined by the provided split points and random
- * chunk versions.
- */
-std::vector<ChunkType> genChunkVector(const UUID& uuid,
-                                      const std::vector<BSONObj>& splitPoints,
-                                      const ChunkVersion& initialVersion,
-                                      size_t numShards);
-
-/*
- * Generate a vector of chunks.
- */
-std::vector<ChunkType> genChunkVector(const UUID& uuid,
-                                      const std::vector<BSONObj>& splitPoints,
-                                      const std::vector<ChunkVersion>& versions,
-                                      size_t numShards);
-
-/*
- * Return a randomly generated vector of chunks that are properly sorted based on their min value
- * and cover the full space from [MinKey, MaxKey].
- */
-std::vector<ChunkType> genRandomChunkVector(const UUID& uuid,
-                                            const OID& epoch,
-                                            const Timestamp& timestamp,
-                                            size_t maxNumChunks,
-                                            size_t minNumChunks = 1);
-
-std::map<ShardId, ChunkVersion> calculateShardVersions(const std::vector<ChunkType>& chunkVector);
-
-std::map<ShardId, Timestamp> calculateShardsMaxValidAfter(
-    const std::vector<ChunkType>& chunkVector);
-
-ChunkVersion calculateCollVersion(const std::map<ShardId, ChunkVersion>& shardVersions);
-
-/*
- * Return a shardkey that is in between the given range [leftKey, rightKey]
- */
-BSONObj calculateIntermediateShardKey(const BSONObj& leftKey,
-                                      const BSONObj& rightKey,
-                                      double minKeyProb = 0.0,
-                                      double maxKeyProb = 0.0);
-
-/*
- * Perform a series of random operations on the given list of chunks.
- *
- * The operations performed resemble all possible operations that could happen to a routing table in
- * a production cluster (move, merge, split, etc...)
- *
- * @chunks: list of chunks ordered by minKey
- * @numOperations: number of operations to perform
- */
-void performRandomChunkOperations(std::vector<ChunkType>* chunks, size_t numOperations);
-
-}  // namespace mongo::chunks_test_util
diff --git a/src/mongo/s/client/shard.cpp b/src/mongo/s/client/shard.cpp
index 1408b227b1e..ac360694af4 100644
--- a/src/mongo/s/client/shard.cpp
+++ b/src/mongo/s/client/shard.cpp
@@ -41,6 +41,7 @@ namespace mongo {
 namespace {
 
 const int kOnErrorNumRetries = 3;
+
 }  // namespace
 
 Status Shard::CommandResponse::getEffectiveStatus(
@@ -193,6 +194,36 @@ StatusWith<Shard::QueryResponse> Shard::runExhaustiveCursorCommand(
     MONGO_UNREACHABLE;
 }
 
+BatchedCommandResponse Shard::runBatchWriteCommand(OperationContext* opCtx,
+                                                   const Milliseconds maxTimeMS,
+                                                   const BatchedCommandRequest& batchRequest,
+                                                   RetryPolicy retryPolicy) {
+    const StringData dbname = batchRequest.getNS().db();
+    const BSONObj cmdObj = batchRequest.toBSON();
+
+    for (int retry = 1; retry <= kOnErrorNumRetries; ++retry) {
+        // Note: write commands can only be issued against a primary.
+        auto swResponse = _runCommand(
+            opCtx, ReadPreferenceSetting{ReadPreference::PrimaryOnly}, dbname, maxTimeMS, cmdObj);
+
+        BatchedCommandResponse batchResponse;
+        auto writeStatus = CommandResponse::processBatchWriteResponse(swResponse, &batchResponse);
+        if (retry < kOnErrorNumRetries && isRetriableError(writeStatus.code(), retryPolicy)) {
+            LOGV2_DEBUG(22721,
+                        2,
+                        "Batch write command to shard {shardId} failed with retryable error "
+                        "and will be retried. Caused by {error}",
+                        "Batch write command failed with retryable error and will be retried",
+                        "shardId"_attr = getId(),
+                        "error"_attr = redact(writeStatus));
+            continue;
+        }
+
+        return batchResponse;
+    }
+    MONGO_UNREACHABLE;
+}
+
 StatusWith<Shard::QueryResponse> Shard::exhaustiveFindOnConfig(
     OperationContext* opCtx,
     const ReadPreferenceSetting& readPref,
@@ -219,34 +250,4 @@ StatusWith<Shard::QueryResponse> Shard::exhaustiveFindOnConfig(
     MONGO_UNREACHABLE;
 }
 
-BatchedCommandResponse Shard::_submitBatchWriteCommand(OperationContext* opCtx,
-                                                       const BSONObj& serialisedBatchRequest,
-                                                       StringData dbName,
-                                                       Milliseconds maxTimeMS,
-                                                       RetryPolicy retryPolicy) {
-    for (int retry = 1; retry <= kOnErrorNumRetries; ++retry) {
-        // Note: write commands can only be issued against a primary.
-        auto swResponse = _runCommand(opCtx,
-                                      ReadPreferenceSetting{ReadPreference::PrimaryOnly},
-                                      dbName,
-                                      maxTimeMS,
-                                      serialisedBatchRequest);
-
-        BatchedCommandResponse batchResponse;
-        auto writeStatus = CommandResponse::processBatchWriteResponse(swResponse, &batchResponse);
-        if (retry < kOnErrorNumRetries && isRetriableError(writeStatus.code(), retryPolicy)) {
-            LOGV2_DEBUG(22721,
-                        2,
-                        "Batch write command failed with retryable error and will be retried",
-                        "shardId"_attr = getId(),
-                        "error"_attr = redact(writeStatus));
-            continue;
-        }
-
-        return batchResponse;
-    }
-    MONGO_UNREACHABLE;
-}
-
-
 }  // namespace mongo
diff --git a/src/mongo/s/client/shard.h b/src/mongo/s/client/shard.h
index e545f0b2f6b..f690341fcb2 100644
--- a/src/mongo/s/client/shard.h
+++ b/src/mongo/s/client/shard.h
@@ -226,11 +226,10 @@ public:
      * commands return errors in a different format than regular commands do, so checking for
      * retriable errors must be done differently.
      */
-    virtual BatchedCommandResponse runBatchWriteCommand(OperationContext* opCtx,
-                                                        Milliseconds maxTimeMS,
-                                                        const BatchedCommandRequest& batchRequest,
-                                                        const WriteConcernOptions& writeConcern,
-                                                        RetryPolicy retryPolicy) = 0;
+    BatchedCommandResponse runBatchWriteCommand(OperationContext* opCtx,
+                                                Milliseconds maxTimeMS,
+                                                const BatchedCommandRequest& batchRequest,
+                                                RetryPolicy retryPolicy);
 
     /**
      * Warning: This method exhausts the cursor and pulls all data into memory.
@@ -293,22 +292,10 @@ public:
 protected:
     Shard(const ShardId& id);
 
-    /**
-     * Submits the batch request applying the specified retry policy and timeout and using the
-     * machinery provided by each implementation.
-     * Callers of this function must ensure to have configured the write concern settings
-     * accordingly to their specific semantics.
-     */
-    BatchedCommandResponse _submitBatchWriteCommand(OperationContext* opCtx,
-                                                    const BSONObj& serialisedBatchRequest,
-                                                    StringData dbName,
-                                                    Milliseconds maxTimeMS,
-                                                    RetryPolicy retryPolicy);
-
 private:
     /**
-     * Runs the specified command against the shard backed by this object with a timeout set to
-     * the minimum of maxTimeMSOverride or the timeout of the OperationContext.
+     * Runs the specified command against the shard backed by this object with a timeout set to the
+     * minimum of maxTimeMSOverride or the timeout of the OperationContext.
      *
      * The return value exposes RemoteShard's host for calls to updateReplSetMonitor.
      *
diff --git a/src/mongo/s/client/shard_registry.cpp b/src/mongo/s/client/shard_registry.cpp
index dfb3932f3c0..d722a9116ec 100644
--- a/src/mongo/s/client/shard_registry.cpp
+++ b/src/mongo/s/client/shard_registry.cpp
@@ -130,8 +130,12 @@ ShardRegistry::Cache::LookupResult ShardRegistry::_lookup(OperationContext* opCt
     // Check if we need to refresh from the configsvrs.  If so, then do that and get the results,
     // otherwise (this is a lookup only to incorporate updated connection strings from the RSM),
     // then get the equivalent values from the previously cached data.
-    auto [returnData, returnTopologyTime, returnForceReloadIncrement, removedShards] =
-        [&]() -> std::tuple<ShardRegistryData, Timestamp, Increment, ShardRegistryData::ShardMap> {
+    auto [returnData,
+          returnTopologyTime,
+          returnForceReloadIncrement,
+          removedShards,
+          fetchedFromConfigServers] = [&]()
+        -> std::tuple<ShardRegistryData, Timestamp, Increment, ShardRegistryData::ShardMap, bool> {
         if (timeInStore.topologyTime > cachedData.getTime().topologyTime ||
             timeInStore.forceReloadIncrement > cachedData.getTime().forceReloadIncrement) {
             auto [reloadedData, maxTopologyTime] =
@@ -140,12 +144,14 @@ ShardRegistry::Cache::LookupResult ShardRegistry::_lookup(OperationContext* opCt
             auto [mergedData, removedShards] =
                 ShardRegistryData::mergeExisting(*cachedData, reloadedData);
 
-            return {mergedData, maxTopologyTime, timeInStore.forceReloadIncrement, removedShards};
+            return {
+                mergedData, maxTopologyTime, timeInStore.forceReloadIncrement, removedShards, true};
         } else {
             return {*cachedData,
                     cachedData.getTime().topologyTime,
                     cachedData.getTime().forceReloadIncrement,
-                    {}};
+                    {},
+                    false};
         }
     }();
 
@@ -180,6 +186,11 @@ ShardRegistry::Cache::LookupResult ShardRegistry::_lookup(OperationContext* opCt
         }
     }
 
+    // The registry is "up" once there has been a successful lookup from the config servers.
+    if (fetchedFromConfigServers) {
+        _isUp.store(true);
+    }
+
     Time returnTime{returnTopologyTime, rsmIncrementForConnStrings, returnForceReloadIncrement};
     LOGV2_DEBUG(4620251,
                 2,
@@ -207,9 +218,9 @@ void ShardRegistry::startupPeriodicReloader(OperationContext* opCtx) {
 
     AsyncTry([this] {
         LOGV2_DEBUG(22726, 1, "Reloading shardRegistry");
-        return _reloadAsyncNoRetry();
+        return _reloadInternal();
     })
-        .until([](auto&& sw) {
+        .until([](auto sw) {
             if (!sw.isOK()) {
                 LOGV2(22727,
                       "Error running periodic reload of shard registry",
@@ -221,7 +232,7 @@ void ShardRegistry::startupPeriodicReloader(OperationContext* opCtx) {
         })
         .withDelayBetweenIterations(kRefreshPeriod)  // This call is optional.
         .on(_executor, CancellationToken::uncancelable())
-        .getAsync([](auto&& sw) {
+        .getAsync([](auto sw) {
             LOGV2_DEBUG(22725,
                         1,
                         "Exiting periodic shard registry reloader",
@@ -284,49 +295,6 @@ StatusWith<std::shared_ptr<Shard>> ShardRegistry::getShard(OperationContext* opC
     return {ErrorCodes::ShardNotFound, str::stream() << "Shard " << shardId << " not found"};
 }
 
-SemiFuture<std::shared_ptr<Shard>> ShardRegistry::getShard(ExecutorPtr executor,
-                                                           const ShardId& shardId) noexcept {
-
-    // Fetch the shard registry data associated to the latest known topology time
-    return _getDataAsync()
-        .thenRunOn(executor)
-        .then([this, executor, shardId](auto&& cachedData) {
-            // First check if this is a non config shard lookup
-            if (auto shard = cachedData->findShard(shardId)) {
-                return SemiFuture<std::shared_ptr<Shard>>::makeReady(std::move(shard));
-            }
-
-            // then check if this is a config shard (this call is blocking in any case)
-            {
-                stdx::lock_guard<Latch> lk(_mutex);
-                if (auto shard = _configShardData.findShard(shardId)) {
-                    return SemiFuture<std::shared_ptr<Shard>>::makeReady(std::move(shard));
-                }
-            }
-
-            // If the shard was not found, force reload the shard regitry data and try again.
-            //
-            // This is to cover the following scenario:
-            // 1. Primary of the replicaset fetch the list of shards and store it on disk
-            // 2. Primary crash before the latest VectorClock topology time is majority written to
-            //    disk
-            // 3. A new primary with a stale ShardRegistry is elected and read the set of shards
-            //    from disk and calls ShardRegistry::getShard
-
-            return _reloadAsync()
-                .thenRunOn(executor)
-                .then([this, executor, shardId](auto&& cachedData) -> std::shared_ptr<Shard> {
-                    auto shard = cachedData->findShard(shardId);
-                    uassert(ErrorCodes::ShardNotFound,
-                            str::stream() << "Shard " << shardId << " not found",
-                            shard);
-                    return shard;
-                })
-                .semi();
-        })
-        .semi();
-}
-
 std::vector<ShardId> ShardRegistry::getAllShardIds(OperationContext* opCtx) {
     auto shardIds = _getData(opCtx)->getAllShardIds();
     if (shardIds.empty()) {
@@ -412,18 +380,8 @@ std::unique_ptr<Shard> ShardRegistry::createConnection(const ConnectionString& c
     return _shardFactory->createUniqueShard(ShardId("<unnamed>"), connStr);
 }
 
-bool ShardRegistry::isUp() {
-    if (_isUp.load())
-        return true;
-
-    // Before the first lookup is completed, the latest cached value is either empty or it is
-    // associated to the default constructed time
-    const auto latestCached = _cache->peekLatestCached(_kSingleton);
-    if (latestCached && latestCached.getTime() != Time()) {
-        _isUp.store(true);
-        return true;
-    }
-    return false;
+bool ShardRegistry::isUp() const {
+    return _isUp.load();
 }
 
 void ShardRegistry::toBSON(BSONObjBuilder* result) const {
@@ -442,26 +400,23 @@ void ShardRegistry::toBSON(BSONObjBuilder* result) const {
 }
 
 void ShardRegistry::reload(OperationContext* opCtx) {
-    _reloadAsync().get(opCtx);
-}
-
-SharedSemiFuture<ShardRegistry::Cache::ValueHandle> ShardRegistry::_reloadAsync() {
     if (MONGO_unlikely(TestingProctor::instance().isEnabled())) {
         // Some unit tests don't support running the reload's AsyncTry on the fixed executor.
-        return _reloadAsyncNoRetry();
+        _reloadInternal().get(opCtx);
     } else {
-        return AsyncTry([=]() mutable { return _reloadAsyncNoRetry(); })
+        AsyncTry([=]() mutable { return _reloadInternal(); })
             .until([](auto sw) mutable {
                 return sw.getStatus() != ErrorCodes::ReadConcernMajorityNotAvailableYet;
             })
             .withBackoffBetweenIterations(kExponentialBackoff)
-            .on(Grid::get(getGlobalServiceContext())->getExecutorPool()->getFixedExecutor(),
+            .on(Grid::get(opCtx)->getExecutorPool()->getFixedExecutor(),
                 CancellationToken::uncancelable())
-            .share();
+            .semi()
+            .get(opCtx);
     }
 }
 
-SharedSemiFuture<ShardRegistry::Cache::ValueHandle> ShardRegistry::_reloadAsyncNoRetry() {
+SharedSemiFuture<ShardRegistry::Cache::ValueHandle> ShardRegistry::_reloadInternal() {
     // Make the next acquire do a lookup.
     auto value = _forceReloadIncrement.addAndFetch(1);
     LOGV2_DEBUG(4620253, 2, "Forcing ShardRegistry reload", "newForceReloadIncrement"_attr = value);
@@ -614,7 +569,7 @@ std::pair<ShardRegistryData, Timestamp> ShardRegistryData::createFromCatalogClie
     OperationContext* opCtx, ShardFactory* shardFactory) {
     auto const catalogClient = Grid::get(opCtx)->catalogClient();
 
-    auto readConcern = repl::ReadConcernLevel::kSnapshotReadConcern;
+    auto readConcern = repl::ReadConcernLevel::kMajorityReadConcern;
 
     // ShardRemote requires a majority read. We can only allow a non-majority read if we are a
     // config server.
diff --git a/src/mongo/s/client/shard_registry.h b/src/mongo/s/client/shard_registry.h
index aceb45db9d2..2c329f11b4c 100644
--- a/src/mongo/s/client/shard_registry.h
+++ b/src/mongo/s/client/shard_registry.h
@@ -239,9 +239,6 @@ public:
      */
     StatusWith<std::shared_ptr<Shard>> getShard(OperationContext* opCtx, const ShardId& shardId);
 
-    SemiFuture<std::shared_ptr<Shard>> getShard(ExecutorPtr executor,
-                                                const ShardId& shardId) noexcept;
-
     /**
      * Returns a vector containing all known shard IDs.
      * The order of the elements is not guaranteed.
@@ -275,7 +272,7 @@ public:
      * The ShardRegistry is "up" once a successful lookup from the config servers has been
      * completed.
      */
-    bool isUp();
+    bool isUp() const;
 
     void toBSON(BSONObjBuilder* result) const;
 
@@ -441,8 +438,7 @@ private:
 
     void _initializeCacheIfNecessary() const;
 
-    SharedSemiFuture<Cache::ValueHandle> _reloadAsync();
-    SharedSemiFuture<Cache::ValueHandle> _reloadAsyncNoRetry();
+    SharedSemiFuture<Cache::ValueHandle> _reloadInternal();
 
     /**
      * Factory to create shards.  Never changed after startup so safe to access outside of _mutex.
diff --git a/src/mongo/s/client/shard_remote.cpp b/src/mongo/s/client/shard_remote.cpp
index 156dad7171a..b678c276510 100644
--- a/src/mongo/s/client/shard_remote.cpp
+++ b/src/mongo/s/client/shard_remote.cpp
@@ -378,16 +378,10 @@ StatusWith<Shard::QueryResponse> ShardRemote::_exhaustiveFindOnConfig(
     }();
 
     BSONObj readConcernObj = [&] {
-        auto readConcern = [&] {
-            if (readConcernLevel == repl::ReadConcernLevel::kMajorityReadConcern) {
-                repl::OpTime configOpTime{configTime.asTimestamp(),
-                                          mongo::repl::OpTime::kUninitializedTerm};
-                return repl::ReadConcernArgs{configOpTime, readConcernLevel};
-            } else {
-                invariant(readConcernLevel == repl::ReadConcernLevel::kSnapshotReadConcern);
-                return repl::ReadConcernArgs{configTime, readConcernLevel};
-            }
-        }();
+        invariant(readConcernLevel == repl::ReadConcernLevel::kMajorityReadConcern);
+        repl::OpTime configOpTime{configTime.asTimestamp(),
+                                  mongo::repl::OpTime::kUninitializedTerm};
+        repl::ReadConcernArgs readConcern{configOpTime, readConcernLevel};
         BSONObjBuilder bob;
         readConcern.appendInfo(&bob);
         return bob.done().getObjectField(repl::ReadConcernArgs::kReadConcernFieldName).getOwned();
@@ -540,23 +534,6 @@ Status ShardRemote::runAggregation(
 }
 
 
-BatchedCommandResponse ShardRemote::runBatchWriteCommand(OperationContext* opCtx,
-                                                         const Milliseconds maxTimeMS,
-                                                         const BatchedCommandRequest& batchRequest,
-                                                         const WriteConcernOptions& writeConcern,
-                                                         RetryPolicy retryPolicy) {
-    const auto dbName = batchRequest.getNS().db();
-    const BSONObj cmdObj = [&] {
-        BSONObjBuilder cmdObjBuilder;
-        batchRequest.serialize(&cmdObjBuilder);
-        cmdObjBuilder.append(WriteConcernOptions::kWriteConcernField, writeConcern.toBSON());
-        return cmdObjBuilder.obj();
-    }();
-
-    return _submitBatchWriteCommand(opCtx, cmdObj, dbName, maxTimeMS, retryPolicy);
-}
-
-
 StatusWith<ShardRemote::AsyncCmdHandle> ShardRemote::_scheduleCommand(
     OperationContext* opCtx,
     const ReadPreferenceSetting& readPref,
diff --git a/src/mongo/s/client/shard_remote.h b/src/mongo/s/client/shard_remote.h
index 6aec3f87da5..6c99a8a5247 100644
--- a/src/mongo/s/client/shard_remote.h
+++ b/src/mongo/s/client/shard_remote.h
@@ -91,12 +91,6 @@ public:
         std::function<bool(const std::vector<BSONObj>& batch,
                            const boost::optional<BSONObj>& postBatchResumeToken)> callback);
 
-    BatchedCommandResponse runBatchWriteCommand(OperationContext* opCtx,
-                                                Milliseconds maxTimeMS,
-                                                const BatchedCommandRequest& batchRequest,
-                                                const WriteConcernOptions& writeConcern,
-                                                RetryPolicy retryPolicy) final;
-
 private:
     struct AsyncCmdHandle {
         HostAndPort hostTargetted;
diff --git a/src/mongo/s/client/sharding_connection_hook.cpp b/src/mongo/s/client/sharding_connection_hook.cpp
index bc72c6ea064..0a7374a240e 100644
--- a/src/mongo/s/client/sharding_connection_hook.cpp
+++ b/src/mongo/s/client/sharding_connection_hook.cpp
@@ -73,14 +73,14 @@ void ShardingConnectionHook::onCreate(DBClientBase* conn) {
 
 
     if (conn->type() == ConnectionString::ConnectionType::kStandalone) {
-        BSONObj helloResponse;
-        if (!conn->runCommand("admin", BSON("hello" << 1), helloResponse)) {
-            uassertStatusOK(getStatusFromCommandResult(helloResponse));
+        BSONObj isMasterResponse;
+        if (!conn->runCommand("admin", BSON("ismaster" << 1), isMasterResponse)) {
+            uassertStatusOK(getStatusFromCommandResult(isMasterResponse));
         }
 
         long long configServerModeNumber;
         Status status =
-            bsonExtractIntegerField(helloResponse, "configsvr", &configServerModeNumber);
+            bsonExtractIntegerField(isMasterResponse, "configsvr", &configServerModeNumber);
 
         if (status == ErrorCodes::NoSuchKey) {
             // This isn't a config server we're talking to.
diff --git a/src/mongo/s/client/sharding_network_connection_hook.cpp b/src/mongo/s/client/sharding_network_connection_hook.cpp
index 60368d2eb0f..a6229316eaa 100644
--- a/src/mongo/s/client/sharding_network_connection_hook.cpp
+++ b/src/mongo/s/client/sharding_network_connection_hook.cpp
@@ -48,12 +48,12 @@ namespace mongo {
 Status ShardingNetworkConnectionHook::validateHost(
     const HostAndPort& remoteHost,
     const BSONObj&,
-    const executor::RemoteCommandResponse& helloReply) {
-    return validateHostImpl(remoteHost, helloReply);
+    const executor::RemoteCommandResponse& isMasterReply) {
+    return validateHostImpl(remoteHost, isMasterReply);
 }
 
 Status ShardingNetworkConnectionHook::validateHostImpl(
-    const HostAndPort& remoteHost, const executor::RemoteCommandResponse& helloReply) {
+    const HostAndPort& remoteHost, const executor::RemoteCommandResponse& isMasterReply) {
     auto shard =
         Grid::get(getGlobalServiceContext())->shardRegistry()->getShardForHostNoReload(remoteHost);
     if (!shard) {
@@ -62,11 +62,11 @@ Status ShardingNetworkConnectionHook::validateHostImpl(
     }
 
     long long configServerModeNumber;
-    auto status = bsonExtractIntegerField(helloReply.data, "configsvr", &configServerModeNumber);
+    auto status = bsonExtractIntegerField(isMasterReply.data, "configsvr", &configServerModeNumber);
 
     switch (status.code()) {
         case ErrorCodes::OK: {
-            // The hello response indicates remoteHost is a config server.
+            // The ismaster response indicates remoteHost is a config server.
             if (!shard->isConfig()) {
                 return {ErrorCodes::InvalidOptions,
                         str::stream() << "Surprised to discover that " << remoteHost.toString()
@@ -75,7 +75,7 @@ Status ShardingNetworkConnectionHook::validateHostImpl(
             return Status::OK();
         }
         case ErrorCodes::NoSuchKey: {
-            // The hello response indicates that remoteHost is not a config server, or that
+            // The ismaster response indicates that remoteHost is not a config server, or that
             // the config server is running a version prior to the 3.1 development series.
             if (!shard->isConfig()) {
                 return Status::OK();
@@ -86,7 +86,7 @@ Status ShardingNetworkConnectionHook::validateHostImpl(
                                   << " does not believe it is a config server"};
         }
         default:
-            // The hello response was malformed.
+            // The ismaster response was malformed.
             return status;
     }
 }
diff --git a/src/mongo/s/client/sharding_network_connection_hook.h b/src/mongo/s/client/sharding_network_connection_hook.h
index d3715dcec1b..c77428e56d9 100644
--- a/src/mongo/s/client/sharding_network_connection_hook.h
+++ b/src/mongo/s/client/sharding_network_connection_hook.h
@@ -45,18 +45,18 @@ public:
 
     /**
      * Checks that the given host is valid to be used in this sharded cluster, based on its
-     * "hello" response.
+     * isMaster response.
      */
     Status validateHost(const HostAndPort& remoteHost,
                         const BSONObj& request,
-                        const executor::RemoteCommandResponse& helloReply) override;
+                        const executor::RemoteCommandResponse& isMasterReply) override;
 
     /**
      * Implementation of validateHost can be called without a ShardingNetworkConnectionHook
      * instance.
      */
     static Status validateHostImpl(const HostAndPort& remoteHost,
-                                   const executor::RemoteCommandResponse& helloReply);
+                                   const executor::RemoteCommandResponse& isMasterReply);
 
     /**
      * Makes a SetShardVersion request for initializing sharding information on the new connection.
diff --git a/src/mongo/s/cluster_commands_helpers.cpp b/src/mongo/s/cluster_commands_helpers.cpp
index 1a84121bf9e..5c0469ab245 100644
--- a/src/mongo/s/cluster_commands_helpers.cpp
+++ b/src/mongo/s/cluster_commands_helpers.cpp
@@ -35,8 +35,6 @@
 
 #include "mongo/s/cluster_commands_helpers.h"
 
-#include "mongo/bson/mutable/algorithm.h"
-#include "mongo/bson/mutable/document.h"
 #include "mongo/bson/util/bson_extract.h"
 #include "mongo/db/catalog/collection_uuid_mismatch_info.h"
 #include "mongo/db/commands.h"
@@ -48,7 +46,6 @@
 #include "mongo/db/query/collation/collator_factory_interface.h"
 #include "mongo/db/query/cursor_response.h"
 #include "mongo/db/repl/read_concern_args.h"
-#include "mongo/db/repl/read_concern_level.h"
 #include "mongo/executor/task_executor_pool.h"
 #include "mongo/rpc/get_status_from_command_result.h"
 #include "mongo/rpc/write_concern_error_detail.h"
@@ -64,11 +61,6 @@
 #include "mongo/s/transaction_router.h"
 #include "mongo/util/scopeguard.h"
 
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kCommand
-
-using mongo::repl::ReadConcernArgs;
-using mongo::repl::ReadConcernLevel;
-
 namespace mongo {
 
 void appendWriteConcernErrorDetailToCmdResponse(const ShardId& shardId,
@@ -139,14 +131,13 @@ namespace {
  * caller.
  */
 std::vector<AsyncRequestsSender::Request> buildVersionedRequestsForTargetedShards(
-    boost::intrusive_ptr<ExpressionContext> expCtx,
+    OperationContext* opCtx,
     const NamespaceString& nss,
     const ChunkManager& cm,
     const std::set<ShardId>& shardsToSkip,
     const BSONObj& cmdObj,
     const BSONObj& query,
     const BSONObj& collation) {
-    auto opCtx = expCtx->opCtx;
 
     auto cmdToSend = cmdObj;
 
@@ -179,6 +170,7 @@ std::vector<AsyncRequestsSender::Request> buildVersionedRequestsForTargetedShard
             CollatorFactoryInterface::get(opCtx->getServiceContext())->makeFromBSON(collation));
     }
 
+    auto expCtx = make_intrusive<ExpressionContext>(opCtx, std::move(collator), nss);
     cm.getShardIdsForQuery(expCtx, query, collation, &shardIds);
 
     for (const ShardId& shardId : shardIds) {
@@ -400,20 +392,6 @@ std::vector<AsyncRequestsSender::Response> scatterGatherUnversionedTargetAllShar
     return gatherResponses(opCtx, dbName, readPref, retryPolicy, requests);
 }
 
-std::vector<AsyncRequestsSender::Response> scatterGatherUnversionedTargetConfigServerAndShards(
-    OperationContext* opCtx,
-    StringData dbName,
-    const BSONObj& cmdObj,
-    const ReadPreferenceSetting& readPref,
-    Shard::RetryPolicy retryPolicy) {
-    std::vector<AsyncRequestsSender::Request> requests;
-    for (auto shardId : Grid::get(opCtx)->shardRegistry()->getAllShardIds(opCtx))
-        requests.emplace_back(std::move(shardId), cmdObj);
-    auto configShardId = Grid::get(opCtx)->shardRegistry()->getConfigShard()->getId();
-    requests.emplace_back(std::move(configShardId), cmdObj);
-    return gatherResponses(opCtx, dbName, readPref, retryPolicy, requests);
-}
-
 std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRoutingTable(
     OperationContext* opCtx,
     StringData dbName,
@@ -423,28 +401,11 @@ std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRouting
     const ReadPreferenceSetting& readPref,
     Shard::RetryPolicy retryPolicy,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants) {
-    auto expCtx = makeExpressionContextWithDefaultsForTargeter(
-        opCtx, nss, collation, boost::none /*explainVerbosity*/, letParameters, runtimeConstants);
-    return scatterGatherVersionedTargetByRoutingTable(
-        expCtx, dbName, nss, cm, cmdObj, readPref, retryPolicy, query, collation);
-}
-
-[[nodiscard]] std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRoutingTable(
-    boost::intrusive_ptr<ExpressionContext> expCtx,
-    StringData dbName,
-    const NamespaceString& nss,
-    const ChunkManager& cm,
-    const BSONObj& cmdObj,
-    const ReadPreferenceSetting& readPref,
-    Shard::RetryPolicy retryPolicy,
-    const BSONObj& query,
     const BSONObj& collation) {
     const auto requests = buildVersionedRequestsForTargetedShards(
-        expCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, collation);
-    return gatherResponses(expCtx->opCtx, dbName, readPref, retryPolicy, requests);
+        opCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, collation);
+
+    return gatherResponses(opCtx, dbName, readPref, retryPolicy, requests);
 }
 
 std::vector<AsyncRequestsSender::Response>
@@ -458,13 +419,9 @@ scatterGatherVersionedTargetByRoutingTableNoThrowOnStaleShardVersionErrors(
     const ReadPreferenceSetting& readPref,
     Shard::RetryPolicy retryPolicy,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants) {
-    auto expCtx = makeExpressionContextWithDefaultsForTargeter(
-        opCtx, nss, collation, boost::none /*explainVerbosity*/, letParameters, runtimeConstants);
+    const BSONObj& collation) {
     const auto requests = buildVersionedRequestsForTargetedShards(
-        expCtx, nss, cm, shardsToSkip, cmdObj, query, collation);
+        opCtx, nss, cm, shardsToSkip, cmdObj, query, collation);
 
     return gatherResponsesNoThrowOnStaleShardVersionErrors(
         opCtx, dbName, readPref, retryPolicy, requests);
@@ -499,12 +456,6 @@ AsyncRequestsSender::Response executeCommandAgainstShardWithMinKeyChunk(
     const BSONObj& cmdObj,
     const ReadPreferenceSetting& readPref,
     Shard::RetryPolicy retryPolicy) {
-    auto expCtx = makeExpressionContextWithDefaultsForTargeter(opCtx,
-                                                               nss,
-                                                               BSONObj() /*collation*/,
-                                                               boost::none /*explainVerbosity*/,
-                                                               boost::none /*letParameters*/,
-                                                               boost::none /*runtimeConstants*/);
 
     const auto query =
         cm.isSharded() ? cm.getShardKeyPattern().getKeyPattern().globalMin() : BSONObj();
@@ -515,7 +466,7 @@ AsyncRequestsSender::Response executeCommandAgainstShardWithMinKeyChunk(
         readPref,
         retryPolicy,
         buildVersionedRequestsForTargetedShards(
-            expCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, BSONObj() /* collation */));
+            opCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, BSONObj() /* collation */));
     return std::move(responses.front());
 }
 
@@ -662,7 +613,7 @@ bool appendEmptyResultSet(OperationContext* opCtx,
                           const std::string& ns) {
     invariant(!status.isOK());
 
-    CurOp::get(opCtx)->debug().additiveMetrics.nreturned = 0;
+    CurOp::get(opCtx)->debug().nreturned = 0;
     CurOp::get(opCtx)->debug().nShards = 0;
 
     if (status == ErrorCodes::NamespaceNotFound) {
@@ -698,14 +649,10 @@ std::vector<std::pair<ShardId, BSONObj>> getVersionedRequestsForTargetedShards(
     const ChunkManager& cm,
     const BSONObj& cmdObj,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants) {
-    auto expCtx = makeExpressionContextWithDefaultsForTargeter(
-        opCtx, nss, collation, boost::none /*explainVerbosity*/, letParameters, runtimeConstants);
+    const BSONObj& collation) {
     std::vector<std::pair<ShardId, BSONObj>> requests;
     auto ars_requests = buildVersionedRequestsForTargetedShards(
-        expCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, collation);
+        opCtx, nss, cm, {} /* shardsToSkip */, cmdObj, query, collation);
     std::transform(std::make_move_iterator(ars_requests.begin()),
                    std::make_move_iterator(ars_requests.end()),
                    std::back_inserter(requests),
@@ -746,13 +693,6 @@ StatusWith<Shard::QueryResponse> loadIndexesFromAuthoritativeShard(OperationCont
     auto [indexShard, listIndexesCmd] = [&]() -> std::pair<std::shared_ptr<Shard>, BSONObj> {
         auto cmdNoVersion = applyReadWriteConcern(
             opCtx, true /* appendRC */, false /* appendWC */, BSON("listIndexes" << nss.coll()));
-
-        // force the read concern level to "local" as other values are not supported for listIndexes
-        BSONObjBuilder bob(cmdNoVersion.removeField(ReadConcernArgs::kReadConcernFieldName));
-        bob.append(ReadConcernArgs::kReadConcernFieldName,
-                   BSON(ReadConcernArgs::kLevelFieldName << repl::readConcernLevels::kLocalName));
-        cmdNoVersion = bob.obj();
-
         if (cm.isSharded()) {
             // For a sharded collection we must load indexes from a shard with chunks. For
             // consistency with cluster listIndexes, load from the shard that owns the minKey chunk.
diff --git a/src/mongo/s/cluster_commands_helpers.h b/src/mongo/s/cluster_commands_helpers.h
index 9f359220d61..f342b7f799e 100644
--- a/src/mongo/s/cluster_commands_helpers.h
+++ b/src/mongo/s/cluster_commands_helpers.h
@@ -86,8 +86,7 @@ boost::intrusive_ptr<ExpressionContext> makeExpressionContextWithDefaultsForTarg
  * Dispatches all the specified requests in parallel and waits until all complete, returning a
  * vector of the same size and positions as that of 'requests'.
  *
- * Throws StaleConfig if any of the remotes returns that error, regardless of what the other errors
- * are.
+ * Throws StaleConfigException if any remote returns a stale shardVersion error.
  */
 std::vector<AsyncRequestsSender::Response> gatherResponses(
     OperationContext* opCtx,
@@ -164,31 +163,10 @@ std::vector<AsyncRequestsSender::Response> scatterGatherUnversionedTargetAllShar
     Shard::RetryPolicy retryPolicy);
 
 /**
- * Utility for dispatching unversioned commands to a dedicated config server if it exists and all
- * shards in a cluster.
- *
- * Returns a non-OK status if a failure occurs on *this* node during execution. Otherwise, returns
- * success and a list of responses from the config server and shards (including errors from the
- * config server or shards or errors reaching the config server or shards).
- *
- * Note, if this mongos has not refreshed its shard list since
- * 1) a shard has been *added* through a different mongos, a request will not be sent to the added
- *    shard
- * 2) a shard has been *removed* through a different mongos, this function will return a
- *    ShardNotFound error status.
- */
-std::vector<AsyncRequestsSender::Response> scatterGatherUnversionedTargetConfigServerAndShards(
-    OperationContext* opCtx,
-    StringData dbName,
-    const BSONObj& cmdObj,
-    const ReadPreferenceSetting& readPref,
-    Shard::RetryPolicy retryPolicy);
-
-/**
  * Utility for dispatching versioned commands on a namespace, deciding which shards to
  * target by applying the passed-in query and collation to the local routing table cache.
  *
- * Does not retry on StaleConfig errors.
+ * Does not retry on StaleConfigException.
  */
 std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRoutingTable(
     OperationContext* opCtx,
@@ -199,32 +177,16 @@ std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRouting
     const ReadPreferenceSetting& readPref,
     Shard::RetryPolicy retryPolicy,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants);
-
-/**
- * This overload is for callers which already have a fully initialized 'ExpressionContext' (e.g.
- * callers from the aggregation framework). Most callers should prefer the overload above.
- */
-[[nodiscard]] std::vector<AsyncRequestsSender::Response> scatterGatherVersionedTargetByRoutingTable(
-    boost::intrusive_ptr<ExpressionContext> expCtx,
-    StringData dbName,
-    const NamespaceString& nss,
-    const ChunkManager& cm,
-    const BSONObj& cmdObj,
-    const ReadPreferenceSetting& readPref,
-    Shard::RetryPolicy retryPolicy,
-    const BSONObj& query,
     const BSONObj& collation);
 
+
 /**
  * Utility for dispatching versioned commands on a namespace, deciding which shards to
  * target by applying the passed-in query and collation to the local routing table cache.
  *
  * Callers can specify shards to skip, even if these shards would be otherwise targeted.
  *
- * Allows StaleConfig errors to append to the response list.
+ * Allows StaleConfigException errors to append to the response list.
  */
 std::vector<AsyncRequestsSender::Response>
 scatterGatherVersionedTargetByRoutingTableNoThrowOnStaleShardVersionErrors(
@@ -237,9 +199,7 @@ scatterGatherVersionedTargetByRoutingTableNoThrowOnStaleShardVersionErrors(
     const ReadPreferenceSetting& readPref,
     Shard::RetryPolicy retryPolicy,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants);
+    const BSONObj& collation);
 
 /**
  * Utility for dispatching commands against the primary of a database and attaching the appropriate
@@ -257,7 +217,7 @@ AsyncRequestsSender::Response executeCommandAgainstDatabasePrimary(
  * Utility for dispatching commands against the shard with the MinKey chunk for the namespace and
  * attaching the appropriate shard version.
  *
- * Does not retry on StaleConfig errors.
+ * Does not retry on StaleConfigException.
  */
 AsyncRequestsSender::Response executeCommandAgainstShardWithMinKeyChunk(
     OperationContext* opCtx,
@@ -331,9 +291,7 @@ std::vector<std::pair<ShardId, BSONObj>> getVersionedRequestsForTargetedShards(
     const ChunkManager& cm,
     const BSONObj& cmdObj,
     const BSONObj& query,
-    const BSONObj& collation,
-    const boost::optional<BSONObj>& letParameters,
-    const boost::optional<LegacyRuntimeConstants>& runtimeConstants);
+    const BSONObj& collation);
 
 /**
  * If the command is running in a transaction, returns the proper routing table to use for targeting
diff --git a/src/mongo/s/cluster_ddl.cpp b/src/mongo/s/cluster_ddl.cpp
index cae979d0aac..a5a4c03b0e3 100644
--- a/src/mongo/s/cluster_ddl.cpp
+++ b/src/mongo/s/cluster_ddl.cpp
@@ -35,7 +35,6 @@
 
 #include "mongo/s/cluster_commands_helpers.h"
 #include "mongo/s/grid.h"
-#include "mongo/s/transaction_router.h"
 
 namespace mongo {
 namespace cluster {
@@ -95,10 +94,6 @@ CachedDatabaseInfo createDatabase(OperationContext* opCtx,
         if (suggestedPrimaryId)
             request.setPrimaryShardId(*suggestedPrimaryId);
 
-        if (auto txnRouter = TransactionRouter::get(opCtx)) {
-            txnRouter.annotateCreatedDatabase(dbName);
-        }
-
         auto configShard = Grid::get(opCtx)->shardRegistry()->getConfigShard();
         auto response = uassertStatusOK(configShard->runCommandWithFixedRetryAttempts(
             opCtx,
diff --git a/src/mongo/s/commands/SConscript b/src/mongo/s/commands/SConscript
index 237324eb92a..be0eb7d5203 100644
--- a/src/mongo/s/commands/SConscript
+++ b/src/mongo/s/commands/SConscript
@@ -53,8 +53,6 @@ env.Library(
         'cluster_find_cmd_s.cpp',
         'cluster_fle2_compact_cmd.cpp',
         'cluster_fsync_cmd.cpp',
-        'cluster_fsync_unlock_cmd.cpp',
-        'cluster_fsync_unlock_cmd.idl',
         'cluster_ftdc_commands.cpp',
         'cluster_get_cluster_parameter_cmd.cpp',
         'cluster_get_last_error_cmd.cpp',
@@ -86,6 +84,7 @@ env.Library(
         'cluster_set_allow_migrations_cmd.cpp',
         'cluster_set_cluster_parameter_cmd.cpp',
         'cluster_set_feature_compatibility_version_cmd.cpp',
+        'cluster_set_free_monitoring_cmd.cpp' if get_option("enable-free-mon") == 'on' else [],
         'cluster_set_index_commit_quorum_cmd.cpp',
         'cluster_set_user_write_block_mode_command.cpp',
         'cluster_shard_collection_cmd.cpp',
@@ -103,7 +102,6 @@ env.Library(
     LIBDEPS_PRIVATE=[
         '$BUILD_DIR/mongo/db/api_parameters',
         '$BUILD_DIR/mongo/db/auth/auth_checks',
-        '$BUILD_DIR/mongo/db/catalog/collection_uuid_mismatch_info',
         '$BUILD_DIR/mongo/db/change_stream_options_manager',
         '$BUILD_DIR/mongo/db/commands/cluster_server_parameter_cmds_idl',
         '$BUILD_DIR/mongo/db/commands/core',
@@ -132,7 +130,6 @@ env.Library(
         '$BUILD_DIR/mongo/db/query/command_request_response',
         '$BUILD_DIR/mongo/db/query/cursor_response_idl',
         '$BUILD_DIR/mongo/db/query/map_reduce_output_format',
-        '$BUILD_DIR/mongo/db/query/query_shape/query_shape',
         '$BUILD_DIR/mongo/db/read_write_concern_defaults',
         '$BUILD_DIR/mongo/db/repl/hello_auth',
         '$BUILD_DIR/mongo/db/repl/hello_command',
diff --git a/src/mongo/s/commands/cluster_coll_stats_cmd.cpp b/src/mongo/s/commands/cluster_coll_stats_cmd.cpp
index d3067b4769e..f85ae09aeb2 100644
--- a/src/mongo/s/commands/cluster_coll_stats_cmd.cpp
+++ b/src/mongo/s/commands/cluster_coll_stats_cmd.cpp
@@ -232,10 +232,8 @@ public:
                 opCtx, this, CommandHelpers::filterCommandRequestForPassthrough(cmdObjToSend)),
             ReadPreferenceSetting::get(opCtx),
             Shard::RetryPolicy::kIdempotent,
-            {} /*query*/,
-            {} /*collation*/,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            {},
+            {});
 
         BSONObjBuilder shardStats;
         std::map<std::string, long long> counts;
diff --git a/src/mongo/s/commands/cluster_collection_mod_cmd.cpp b/src/mongo/s/commands/cluster_collection_mod_cmd.cpp
index 42e318aaa57..d295ca18c71 100644
--- a/src/mongo/s/commands/cluster_collection_mod_cmd.cpp
+++ b/src/mongo/s/commands/cluster_collection_mod_cmd.cpp
@@ -33,7 +33,6 @@
 
 #include "mongo/db/auth/authorization_checks.h"
 #include "mongo/db/auth/authorization_session.h"
-#include "mongo/db/catalog/collection_uuid_mismatch_info.h"
 #include "mongo/db/coll_mod_gen.h"
 #include "mongo/db/coll_mod_reply_validation.h"
 #include "mongo/db/commands.h"
@@ -94,17 +93,8 @@ public:
                     "namespace"_attr = nss,
                     "command"_attr = redact(cmdObj));
 
-        auto swDbInfo = Grid::get(opCtx)->catalogCache()->getDatabase(opCtx, cmd.getDbName());
-        if (swDbInfo == ErrorCodes::NamespaceNotFound) {
-            uassert(CollectionUUIDMismatchInfo(cmd.getDbName().toString(),
-                                               *cmd.getCollectionUUID(),
-                                               nss.coll().toString(),
-                                               boost::none),
-                    "Database does not exist",
-                    !cmd.getCollectionUUID());
-        }
-        const auto dbInfo = uassertStatusOK(swDbInfo);
-
+        const auto dbInfo =
+            uassertStatusOK(Grid::get(opCtx)->catalogCache()->getDatabase(opCtx, cmd.getDbName()));
         ShardsvrCollMod collModCommand(nss);
         collModCommand.setCollModRequest(cmd.getCollModRequest());
         auto cmdResponse =
diff --git a/src/mongo/s/commands/cluster_convert_to_capped_cmd.cpp b/src/mongo/s/commands/cluster_convert_to_capped_cmd.cpp
index c6206bce5be..8c657bc453f 100644
--- a/src/mongo/s/commands/cluster_convert_to_capped_cmd.cpp
+++ b/src/mongo/s/commands/cluster_convert_to_capped_cmd.cpp
@@ -51,17 +51,8 @@ bool nonShardedCollectionCommandPassthrough(OperationContext* opCtx,
             str::stream() << "Can't do command: " << cmdName << " on a sharded collection",
             !cm.isSharded());
 
-    auto responses = scatterGatherVersionedTargetByRoutingTable(opCtx,
-                                                                dbName,
-                                                                nss,
-                                                                cm,
-                                                                cmdObj,
-                                                                ReadPreferenceSetting::get(opCtx),
-                                                                retryPolicy,
-                                                                {} /*query*/,
-                                                                {} /*collation*/,
-                                                                boost::none /*letParameters*/,
-                                                                boost::none /*runtimeConstants*/);
+    auto responses = scatterGatherVersionedTargetByRoutingTable(
+        opCtx, dbName, nss, cm, cmdObj, ReadPreferenceSetting::get(opCtx), retryPolicy, {}, {});
     invariant(responses.size() == 1);
 
     const auto cmdResponse = uassertStatusOK(std::move(responses.front().swResponse));
diff --git a/src/mongo/s/commands/cluster_count_cmd.cpp b/src/mongo/s/commands/cluster_count_cmd.cpp
index 94e6c7c0eee..48545c7c0d7 100644
--- a/src/mongo/s/commands/cluster_count_cmd.cpp
+++ b/src/mongo/s/commands/cluster_count_cmd.cpp
@@ -131,9 +131,7 @@ public:
                 ReadPreferenceSetting::get(opCtx),
                 Shard::RetryPolicy::kIdempotent,
                 countRequest.getQuery(),
-                collation,
-                boost::none /*letParameters*/,
-                boost::none /*runtimeConstants*/);
+                collation);
         } catch (const ExceptionFor<ErrorCodes::CommandOnShardedViewNotSupportedOnMongod>& ex) {
             // Rewrite the count command as an aggregation.
             auto countRequest = CountCommandRequest::parse(IDLParserErrorContext("count"), cmdObj);
@@ -237,9 +235,7 @@ public:
                                                            ReadPreferenceSetting::get(opCtx),
                                                            Shard::RetryPolicy::kIdempotent,
                                                            targetingQuery,
-                                                           targetingCollation,
-                                                           boost::none /*letParameters*/,
-                                                           boost::none /*runtimeConstants*/);
+                                                           targetingCollation);
         } catch (const ExceptionFor<ErrorCodes::CommandOnShardedViewNotSupportedOnMongod>& ex) {
             CountCommandRequest countRequest(NamespaceStringOrUUID(NamespaceString{}));
             try {
@@ -288,14 +284,14 @@ private:
         BSONElement l = cmd["limit"];
 
         if (s.isNumber()) {
-            num = num - s.safeNumberLong();
+            num = num - s.numberLong();
             if (num < 0) {
                 num = 0;
             }
         }
 
         if (l.isNumber()) {
-            auto limit = l.safeNumberLong();
+            long long limit = l.numberLong();
             if (limit < 0) {
                 limit = -limit;
             }
diff --git a/src/mongo/s/commands/cluster_create_indexes_cmd.cpp b/src/mongo/s/commands/cluster_create_indexes_cmd.cpp
index 8f4928444c4..8c4c8af8784 100644
--- a/src/mongo/s/commands/cluster_create_indexes_cmd.cpp
+++ b/src/mongo/s/commands/cluster_create_indexes_cmd.cpp
@@ -89,6 +89,8 @@ public:
                     "namespace"_attr = nss,
                     "command"_attr = redact(cmdObj));
 
+        cluster::createDatabase(opCtx, dbName);
+
         auto targeter = ChunkManagerTargeter(opCtx, nss);
         auto routingInfo = targeter.getRoutingInfo();
         auto cmdToBeSent = cmdObj;
@@ -106,10 +108,8 @@ public:
                 applyReadWriteConcern(opCtx, this, cmdToBeSent)),
             ReadPreferenceSetting(ReadPreference::PrimaryOnly),
             Shard::RetryPolicy::kNoRetry,
-            BSONObj() /*query*/,
-            BSONObj() /*collation*/,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            BSONObj() /* query */,
+            BSONObj() /* collation */);
 
         std::string errmsg;
         const bool ok =
diff --git a/src/mongo/s/commands/cluster_data_size_cmd.cpp b/src/mongo/s/commands/cluster_data_size_cmd.cpp
index 1c87c6a98f0..7d645d1a51c 100644
--- a/src/mongo/s/commands/cluster_data_size_cmd.cpp
+++ b/src/mongo/s/commands/cluster_data_size_cmd.cpp
@@ -85,10 +85,8 @@ public:
                 opCtx, this, CommandHelpers::filterCommandRequestForPassthrough(cmdObj)),
             ReadPreferenceSetting::get(opCtx),
             Shard::RetryPolicy::kIdempotent,
-            {} /*query*/,
-            {} /*collation*/,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            {},
+            {});
 
         // yes these are doubles...
         double size = 0;
diff --git a/src/mongo/s/commands/cluster_distinct_cmd.cpp b/src/mongo/s/commands/cluster_distinct_cmd.cpp
index f34377258e4..70ae5f4b671 100644
--- a/src/mongo/s/commands/cluster_distinct_cmd.cpp
+++ b/src/mongo/s/commands/cluster_distinct_cmd.cpp
@@ -132,9 +132,7 @@ public:
                                                            ReadPreferenceSetting::get(opCtx),
                                                            Shard::RetryPolicy::kIdempotent,
                                                            targetingQuery,
-                                                           targetingCollation,
-                                                           boost::none /*letParameters*/,
-                                                           boost::none /*runtimeConstants*/);
+                                                           targetingCollation);
         } catch (const ExceptionFor<ErrorCodes::CommandOnShardedViewNotSupportedOnMongod>& ex) {
             auto parsedDistinct = ParsedDistinct::parse(
                 opCtx, ex->getNamespace(), cmdObj, ExtensionsCallbackNoop(), true);
@@ -219,9 +217,7 @@ public:
                 ReadPreferenceSetting::get(opCtx),
                 Shard::RetryPolicy::kIdempotent,
                 query,
-                collation,
-                boost::none /*letParameters*/,
-                boost::none /*runtimeConstants*/);
+                collation);
         } catch (const ExceptionFor<ErrorCodes::CommandOnShardedViewNotSupportedOnMongod>& ex) {
             auto parsedDistinct = ParsedDistinct::parse(
                 opCtx, ex->getNamespace(), cmdObj, ExtensionsCallbackNoop(), true);
diff --git a/src/mongo/s/commands/cluster_drop_collection_cmd.cpp b/src/mongo/s/commands/cluster_drop_collection_cmd.cpp
index 40e9196371f..e16f473ab3c 100644
--- a/src/mongo/s/commands/cluster_drop_collection_cmd.cpp
+++ b/src/mongo/s/commands/cluster_drop_collection_cmd.cpp
@@ -33,7 +33,6 @@
 
 #include "mongo/base/status.h"
 #include "mongo/db/auth/authorization_session.h"
-#include "mongo/db/catalog/collection_uuid_mismatch_info.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/drop_gen.h"
 #include "mongo/db/operation_context.h"
@@ -117,13 +116,6 @@ public:
                 // Ensure our reply conforms to the IDL-defined reply structure.
                 return DropReply::parse({"drop"}, resultObj);
             } catch (const ExceptionFor<ErrorCodes::NamespaceNotFound>&) {
-                uassert(CollectionUUIDMismatchInfo(request().getDbName().toString(),
-                                                   *request().getCollectionUUID(),
-                                                   request().getNamespace().coll().toString(),
-                                                   boost::none),
-                        "Database does not exist",
-                        !request().getCollectionUUID());
-
                 // If the namespace isn't found, treat the drop as a success but inform about the
                 // failure.
                 DropReply reply;
diff --git a/src/mongo/s/commands/cluster_filemd5_cmd.cpp b/src/mongo/s/commands/cluster_filemd5_cmd.cpp
index 3248d9ce0ba..d351a7be7a3 100644
--- a/src/mongo/s/commands/cluster_filemd5_cmd.cpp
+++ b/src/mongo/s/commands/cluster_filemd5_cmd.cpp
@@ -98,9 +98,7 @@ public:
                                                            ReadPreferenceSetting::get(opCtx),
                                                            Shard::RetryPolicy::kIdempotent,
                                                            routingQuery,
-                                                           CollationSpec::kSimpleSpec,
-                                                           boost::none /*letParameters*/,
-                                                           boost::none /*runtimeConstants*/);
+                                                           CollationSpec::kSimpleSpec);
             invariant(shardResults.size() == 1);
             const auto shardResponse = uassertStatusOK(std::move(shardResults[0].swResponse));
             uassertStatusOK(shardResponse.status);
diff --git a/src/mongo/s/commands/cluster_find_and_modify_cmd.cpp b/src/mongo/s/commands/cluster_find_and_modify_cmd.cpp
index 195adef15e2..740d1561487 100644
--- a/src/mongo/s/commands/cluster_find_and_modify_cmd.cpp
+++ b/src/mongo/s/commands/cluster_find_and_modify_cmd.cpp
@@ -69,8 +69,6 @@
 namespace mongo {
 namespace {
 
-constexpr size_t kMaxDatabaseCreationAttempts = 3u;
-
 const ReadPreferenceSetting kPrimaryOnlyReadPreference(ReadPreference::PrimaryOnly);
 const char kLegacyRuntimeConstantsField[] = "runtimeConstants";
 
@@ -307,27 +305,6 @@ void handleWouldChangeOwningShardErrorTransactionLegacy(OperationContext* opCtx,
     }
 }
 
-ShardId targetSingleShard(boost::intrusive_ptr<ExpressionContext> expCtx,
-                          const ChunkManager& cm,
-                          const BSONObj& query,
-                          const BSONObj& collation) {
-    std::set<ShardId> shardIds;
-
-    // For now, set bypassIsFieldHashedCheck to be true in order to skip the
-    // isFieldHashedCheck in the special case where _id is hashed and used as the shard
-    // key. This means that we always assume that a findAndModify request using _id is
-    // targetable to a single shard.
-    cm.getShardIdsForQuery(expCtx, query, collation, &shardIds, true);
-
-    uassert(ErrorCodes::ShardKeyNotFound,
-            str::stream() << "Query with sharded findAndModify expected to only target one "
-                             "shard, but the query targeted "
-                          << shardIds.size() << " shard(s)",
-            shardIds.size() == 1);
-
-    return *shardIds.begin();
-}
-
 class FindAndModifyCmd : public BasicCommand {
 public:
     FindAndModifyCmd()
@@ -415,14 +392,12 @@ public:
             const BSONObj collation = getCollation(cmdObj);
             const auto let = getLet(cmdObj);
             const auto rc = getLegacyRuntimeConstants(cmdObj);
-            ShardId shardId;
-            {
-                auto expCtx = makeExpressionContextWithDefaultsForTargeter(
-                    opCtx, nss, collation, verbosity, let, rc);
-                shardId = targetSingleShard(expCtx, cm, query, collation);
-            }
+            const BSONObj shardKey =
+                getShardKey(opCtx, cm, nss, query, collation, verbosity, let, rc);
+            const auto chunk = cm.findIntersectingChunk(shardKey, collation);
 
-            shard = uassertStatusOK(Grid::get(opCtx)->shardRegistry()->getShard(opCtx, shardId));
+            shard = uassertStatusOK(
+                Grid::get(opCtx)->shardRegistry()->getShard(opCtx, chunk.getShardId()));
         } else {
             shard =
                 uassertStatusOK(Grid::get(opCtx)->shardRegistry()->getShard(opCtx, cm.dbPrimary()));
@@ -484,50 +459,31 @@ public:
         // Collect metrics.
         _updateMetrics.collectMetrics(cmdObj);
 
-        const auto cm = [&]() {
-            size_t attempts = 1u;
-            while (true) {
-                try {
-                    // Technically, findAndModify should only be creating database if upsert is
-                    // true, but this would require that the parsing be pulled into this function.
-                    cluster::createDatabase(opCtx, nss.db());
-                    return uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, nss));
-                } catch (const ExceptionFor<ErrorCodes::NamespaceNotFound>&) {
-                    LOGV2_INFO(
-                        8584300,
-                        "Failed initialization of routing info because the database has been "
-                        "concurrently dropped",
-                        logAttrs(nss),
-                        "attemptNumber"_attr = attempts,
-                        "maxAttempts"_attr = kMaxDatabaseCreationAttempts);
-
-                    if (attempts++ >= kMaxDatabaseCreationAttempts) {
-                        // The maximum number of attempts has been reached, so the procedure fails
-                        // as it could be a logical error. At this point, it is unlikely that the
-                        // error is caused by concurrent drop database operations.
-                        throw;
-                    }
-                }
-            }
-        }();
+        // Technically, findAndModify should only be creating database if upsert is true, but this
+        // would require that the parsing be pulled into this function.
+        cluster::createDatabase(opCtx, nss.db());
 
         // Append mongoS' runtime constants to the command object before forwarding it to the shard.
         auto cmdObjForShard = appendLegacyRuntimeConstantsToCommandObject(opCtx, cmdObj);
 
+        const auto cm = uassertStatusOK(getCollectionRoutingInfoForTxnCmd(opCtx, nss));
         if (cm.isSharded()) {
             const BSONObj query = cmdObjForShard.getObjectField("query");
             const BSONObj collation = getCollation(cmdObjForShard);
             const auto let = getLet(cmdObjForShard);
             const auto rc = getLegacyRuntimeConstants(cmdObjForShard);
-            ShardId shardId;
-            {
-                auto expCtx = makeExpressionContextWithDefaultsForTargeter(
-                    opCtx, nss, collation, boost::none, let, rc);
-                shardId = targetSingleShard(expCtx, cm, query, collation);
-            }
+            const BSONObj shardKey =
+                getShardKey(opCtx, cm, nss, query, collation, boost::none, let, rc);
+
+            // For now, set bypassIsFieldHashedCheck to be true in order to skip the
+            // isFieldHashedCheck in the special case where _id is hashed and used as the shard key.
+            // This means that we always assume that a findAndModify request using _id is targetable
+            // to a single shard.
+            auto chunk = cm.findIntersectingChunk(shardKey, collation, true);
+
             _runCommand(opCtx,
-                        shardId,
-                        cm.getVersion(shardId),
+                        chunk.getShardId(),
+                        cm.getVersion(chunk.getShardId()),
                         boost::none,
                         nss,
                         applyReadWriteConcern(opCtx, this, cmdObjForShard),
diff --git a/src/mongo/s/commands/cluster_find_cmd.h b/src/mongo/s/commands/cluster_find_cmd.h
index 6476d883200..87d25934d0c 100644
--- a/src/mongo/s/commands/cluster_find_cmd.h
+++ b/src/mongo/s/commands/cluster_find_cmd.h
@@ -38,9 +38,6 @@
 #include "mongo/db/fle_crud.h"
 #include "mongo/db/matcher/extensions_callback_noop.h"
 #include "mongo/db/query/cursor_response.h"
-#include "mongo/db/query/query_shape/query_shape.h"
-#include "mongo/db/query/query_stats/find_key.h"
-#include "mongo/db/query/query_stats/query_stats.h"
 #include "mongo/db/stats/counters.h"
 #include "mongo/db/views/resolved_view.h"
 #include "mongo/rpc/get_status_from_command_result.h"
@@ -155,9 +152,7 @@ public:
                     ReadPreferenceSetting::get(opCtx),
                     Shard::RetryPolicy::kIdempotent,
                     findCommand->getFilter(),
-                    findCommand->getCollation(),
-                    findCommand->getLet(),
-                    findCommand->getLegacyRuntimeConstants());
+                    findCommand->getCollation());
                 millisElapsed = timer.millis();
 
                 const char* mongosStageName =
@@ -204,23 +199,21 @@ public:
 
             Impl::checkCanRunHere(opCtx);
 
-            auto&& parsedFindResult = uassertStatusOK(parsed_find_command::parse(
-                opCtx,
-                _parseCmdObjectToFindCommandRequest(opCtx, ns(), _request.body),
-                ExtensionsCallbackNoop(),
-                MatchExpressionParser::kAllowAllSpecialFeatures));
-            auto& expCtx = parsedFindResult.first;
-            auto& parsedFind = parsedFindResult.second;
-
-            if (!_didDoFLERewrite) {
-                query_stats::registerRequest(opCtx, expCtx->ns, [&]() {
-                    // This callback is either never invoked or invoked
-                    // immediately within registerRequest, so
-                    // use-after-move of parsedFind isn't an issue.
-                    return std::make_unique<query_stats::FindKey>(expCtx, *parsedFind);
-                });
-            }
-            auto cq = uassertStatusOK(CanonicalQuery::canonicalize(expCtx, std::move(parsedFind)));
+            ON_BLOCK_EXIT([opCtx] {
+                Grid::get(opCtx)->catalogCache()->checkAndRecordOperationBlockedByRefresh(
+                    opCtx, mongo::LogicalOp::opQuery);
+            });
+
+            auto findCommand = _parseCmdObjectToFindCommandRequest(opCtx, ns(), _request.body);
+
+            const boost::intrusive_ptr<ExpressionContext> expCtx;
+            auto cq = uassertStatusOK(
+                CanonicalQuery::canonicalize(opCtx,
+                                             std::move(findCommand),
+                                             false, /* isExplain */
+                                             expCtx,
+                                             ExtensionsCallbackNoop(),
+                                             MatchExpressionParser::kAllowAllSpecialFeatures));
 
             try {
                 // Do the work to generate the first batch of results. This blocks waiting to get
@@ -274,7 +267,7 @@ public:
          * were supplied with the command, and sets the constant runtime values that will be
          * forwarded to each shard.
          */
-        std::unique_ptr<FindCommandRequest> _parseCmdObjectToFindCommandRequest(
+        static std::unique_ptr<FindCommandRequest> _parseCmdObjectToFindCommandRequest(
             OperationContext* opCtx, NamespaceString nss, BSONObj cmdObj) {
             auto findCommand = query_request_helper::makeFromFindCommand(
                 std::move(cmdObj),
@@ -301,7 +294,6 @@ public:
                 invariant(findCommand->getNamespaceOrUUID().nss());
                 processFLEFindS(
                     opCtx, findCommand->getNamespaceOrUUID().nss().get(), findCommand.get());
-                _didDoFLERewrite = true;
             }
 
             return findCommand;
@@ -309,7 +301,6 @@ public:
 
         const OpMsgRequest& _request;
         const StringData _dbName;
-        bool _didDoFLERewrite{false};
     };
 };
 
diff --git a/src/mongo/s/commands/cluster_fle2_compact_cmd.cpp b/src/mongo/s/commands/cluster_fle2_compact_cmd.cpp
index 7abae202f17..b1cecbf555e 100644
--- a/src/mongo/s/commands/cluster_fle2_compact_cmd.cpp
+++ b/src/mongo/s/commands/cluster_fle2_compact_cmd.cpp
@@ -32,7 +32,6 @@
 #include "mongo/db/auth/authorization_session.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/commands/fle2_compact_gen.h"
-#include "mongo/db/curop.h"
 #include "mongo/s/cluster_commands_helpers.h"
 #include "mongo/s/grid.h"
 
diff --git a/src/mongo/s/commands/cluster_fsync_cmd.cpp b/src/mongo/s/commands/cluster_fsync_cmd.cpp
index 55316c964ac..e82469acee3 100644
--- a/src/mongo/s/commands/cluster_fsync_cmd.cpp
+++ b/src/mongo/s/commands/cluster_fsync_cmd.cpp
@@ -31,18 +31,10 @@
 
 #include "mongo/client/read_preference.h"
 #include "mongo/client/remote_command_targeter.h"
-#include "mongo/db/auth/authorization_session.h"
 #include "mongo/db/commands.h"
-#include "mongo/db/operation_context.h"
-#include "mongo/db/service_context.h"
 #include "mongo/s/client/shard.h"
 #include "mongo/s/client/shard_registry.h"
-#include "mongo/s/cluster_commands_helpers.h"
 #include "mongo/s/grid.h"
-#include "mongo/s/sharding_feature_flags_gen.h"
-#include "mongo/util/assert_util.h"
-
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kCommand
 
 namespace mongo {
 namespace {
@@ -75,47 +67,53 @@ public:
         out->push_back(Privilege(ResourcePattern::forClusterResource(), actions));
     }
 
-    void unlockLockedShards(OperationContext* opCtx, const std::string& dbname) {
-
-        auto request = OpMsgRequest::fromDBAndBody(dbname, BSON("fsyncUnlock" << 1));
-        auto response = CommandHelpers::runCommandDirectly(opCtx, request);
-    }
-
     bool errmsgRun(OperationContext* opCtx,
                    const std::string& dbname,
                    const BSONObj& cmdObj,
                    std::string& errmsg,
                    BSONObjBuilder& result) override {
-
-        BSONObj fsyncCmdObj = cmdObj;
         if (cmdObj["lock"].trueValue()) {
-            auto forBackupField = BSON("forBackup" << true);
-            fsyncCmdObj = fsyncCmdObj.addFields(forBackupField);
+            errmsg = "can't do lock through mongos";
+            return false;
         }
 
-        auto shardResults = scatterGatherUnversionedTargetConfigServerAndShards(
-            opCtx,
-            dbname,
-            applyReadWriteConcern(
-                opCtx, this, CommandHelpers::filterCommandRequestForPassthrough(fsyncCmdObj)),
-            ReadPreferenceSetting(ReadPreference::PrimaryOnly),
-            Shard::RetryPolicy::kIdempotent);
+        BSONObjBuilder sub;
 
-        BSONObjBuilder rawResult;
-        const auto response = appendRawResponses(opCtx, &errmsg, &rawResult, shardResults);
+        bool ok = true;
+
+        auto const shardRegistry = Grid::get(opCtx)->shardRegistry();
+        const auto shardIds = shardRegistry->getAllShardIdsNoReload();
+
+        for (const ShardId& shardId : shardIds) {
+            auto shardStatus = shardRegistry->getShard(opCtx, shardId);
+            if (!shardStatus.isOK()) {
+                continue;
+            }
+            const auto s = shardStatus.getValue();
+
+            auto response = uassertStatusOK(s->runCommandWithFixedRetryAttempts(
+                opCtx,
+                ReadPreferenceSetting{ReadPreference::PrimaryOnly},
+                "admin",
+                BSON("fsync" << 1),
+                Shard::RetryPolicy::kIdempotent));
+            uassertStatusOK(response.commandStatus);
+            BSONObj x = std::move(response.response);
+
+            sub.append(s->getId().toString(), x);
+
+            if (!x["ok"].trueValue()) {
+                ok = false;
+                errmsg = x["errmsg"].String();
+            }
+        }
 
         // This field has had dummy value since MMAP went away. It is undocumented.
         // Maintaining it so as not to cause unnecessary user pain across upgrades.
         result.append("numFiles", 1);
-        result.append("all", rawResult.obj());
-        if (!response.responseOK) {
-            if (cmdObj["lock"].trueValue()) {
-                unlockLockedShards(opCtx, dbname);
-            }
-            return false;
-        }
+        result.append("all", sub.obj());
 
-        return true;
+        return ok;
     }
 
 } clusterFsyncCmd;
diff --git a/src/mongo/s/commands/cluster_fsync_unlock_cmd.cpp b/src/mongo/s/commands/cluster_fsync_unlock_cmd.cpp
deleted file mode 100644
index 5275298a7bb..00000000000
--- a/src/mongo/s/commands/cluster_fsync_unlock_cmd.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-/**
- *    Copyright (C) 2023-present MongoDB, Inc.
- *
- *    This program is free software: you can redistribute it and/or modify
- *    it under the terms of the Server Side Public License, version 1,
- *    as published by MongoDB, Inc.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    Server Side Public License for more details.
- *
- *    You should have received a copy of the Server Side Public License
- *    along with this program. If not, see
- *    <http://www.mongodb.com/licensing/server-side-public-license>.
- *
- *    As a special exception, the copyright holders give permission to link the
- *    code of portions of this program with the OpenSSL library under certain
- *    conditions as described in each individual source file and distribute
- *    linked combinations including the program with the OpenSSL library. You
- *    must comply with the Server Side Public License in all respects for
- *    all of the code used other than as permitted herein. If you modify file(s)
- *    with this exception, you may extend this exception to your version of the
- *    file(s), but you are not obligated to do so. If you do not wish to do so,
- *    delete this exception statement from your version. If you delete this
- *    exception statement from all source files in the program, then also delete
- *    it in the license file.
- */
-
-#include "mongo/platform/basic.h"
-
-#include "mongo/client/read_preference.h"
-#include "mongo/client/remote_command_targeter.h"
-#include "mongo/db/auth/authorization_session.h"
-#include "mongo/db/commands.h"
-#include "mongo/s/async_requests_sender.h"
-#include "mongo/s/client/shard.h"
-#include "mongo/s/client/shard_registry.h"
-#include "mongo/s/cluster_commands_helpers.h"
-#include "mongo/s/commands/cluster_fsync_unlock_cmd_gen.h"
-#include "mongo/s/grid.h"
-#include "mongo/s/sharding_feature_flags_gen.h"
-
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kCommand
-
-namespace mongo {
-
-namespace {
-class FsyncUnlockCommand : public TypedCommand<FsyncUnlockCommand> {
-public:
-    using Request = ClusterFsyncUnlock;
-
-
-    class Invocation final : public InvocationBase {
-    public:
-        using InvocationBase::InvocationBase;
-
-        /**
-         * Intermediate wrapper to interface with ReplyBuilderInterface.
-         */
-        class Response {
-        public:
-            Response(BSONObj obj) : _obj(std::move(obj)) {}
-
-            void serialize(BSONObjBuilder* builder) const {
-                builder->appendElements(_obj);
-            }
-
-        private:
-            const BSONObj _obj;
-        };
-
-        Response typedRun(OperationContext* opCtx) {
-            BSONObj fsyncUnlockCmdObj = BSON("fsyncUnlock" << 1);
-
-            auto responses = scatterGatherUnversionedTargetConfigServerAndShards(
-                opCtx,
-                NamespaceString::kAdminDb,
-                applyReadWriteConcern(
-                    opCtx,
-                    this,
-                    CommandHelpers::filterCommandRequestForPassthrough(fsyncUnlockCmdObj)),
-                ReadPreferenceSetting::get(opCtx),
-                Shard::RetryPolicy::kIdempotent);
-
-            BSONObjBuilder result;
-            std::string errmsg;
-            const auto rawResponsesResult = appendRawResponses(opCtx, &errmsg, &result, responses);
-
-            if (!errmsg.empty()) {
-                CommandHelpers::appendSimpleCommandStatus(
-                    result, rawResponsesResult.responseOK, errmsg);
-            }
-
-            return Response(result.obj());
-        }
-
-    private:
-        NamespaceString ns() const override {
-            return {};
-        }
-
-        bool supportsWriteConcern() const override {
-            return false;
-        }
-
-        void doCheckAuthorization(OperationContext* opCtx) const override {
-            uassert(ErrorCodes::Unauthorized,
-                    "Unauthorized",
-                    AuthorizationSession::get(opCtx->getClient())
-                        ->isAuthorizedForActionsOnResource(ResourcePattern::forExactNamespace(ns()),
-                                                           ActionType::fsyncUnlock));
-        }
-    };
-
-    AllowedOnSecondary secondaryAllowed(ServiceContext*) const override {
-        return AllowedOnSecondary::kAlways;
-    }
-
-    bool maintenanceOk() const override {
-        return false;
-    }
-
-    bool adminOnly() const override {
-        return true;
-    }
-
-    std::string help() const override {
-        return "invoke fsync unlock on all shards belonging to the cluster";
-    }
-} fsyncUnlockCmd;
-
-}  // namespace
-}  // namespace mongo
diff --git a/src/mongo/s/commands/cluster_fsync_unlock_cmd.idl b/src/mongo/s/commands/cluster_fsync_unlock_cmd.idl
deleted file mode 100644
index c0d1be0aa0c..00000000000
--- a/src/mongo/s/commands/cluster_fsync_unlock_cmd.idl
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (C) 2023-present MongoDB, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the Server Side Public License, version 1,
-# as published by MongoDB, Inc.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# Server Side Public License for more details.
-#
-# You should have received a copy of the Server Side Public License
-# along with this program. If not, see
-# <http://www.mongodb.com/licensing/server-side-public-license>.
-#
-# As a special exception, the copyright holders give permission to link the
-# code of portions of this program with the OpenSSL library under certain
-# conditions as described in each individual source file and distribute
-# linked combinations including the program with the OpenSSL library. You
-# must comply with the Server Side Public License in all respects for
-# all of the code used other than as permitted herein. If you modify file(s)
-# with this exception, you may extend this exception to your version of the
-# file(s), but you are not obligated to do so. If you do not wish to do so,
-# delete this exception statement from your version. If you delete this
-# exception statement from all source files in the program, then also delete
-# it in the license file.
-#
-
-global:
-    cpp_namespace: "mongo"
-
-imports:
-    - "mongo/idl/basic_types.idl"
-
-commands:
-    clusterFsyncUnlock:
-        description: "The command for calling fsync unlock on all shards of a cluster."
-        command_name: fsyncUnlock
-        cpp_name: clusterFsyncUnlock
-        strict: false
-        namespace: ignored
-        api_version: "" 
diff --git a/src/mongo/s/commands/cluster_get_cluster_parameter_cmd.cpp b/src/mongo/s/commands/cluster_get_cluster_parameter_cmd.cpp
index 4b6d49ebae1..1058e6ebafd 100644
--- a/src/mongo/s/commands/cluster_get_cluster_parameter_cmd.cpp
+++ b/src/mongo/s/commands/cluster_get_cluster_parameter_cmd.cpp
@@ -66,11 +66,6 @@ public:
         using InvocationBase::InvocationBase;
 
         Reply typedRun(OperationContext* opCtx) {
-            uassert(ErrorCodes::UnknownFeatureCompatibilityVersion,
-                    "FCV is not yet initialized, retry the command after FCV initialization has "
-                    "completed",
-                    serverGlobalParams.featureCompatibility.isVersionInitialized());
-
             uassert(
                 ErrorCodes::IllegalOperation,
                 "featureFlagClusterWideConfig not enabled",
diff --git a/src/mongo/s/commands/cluster_hello_cmd.cpp b/src/mongo/s/commands/cluster_hello_cmd.cpp
index 13b199f8ad3..5600a29661d 100644
--- a/src/mongo/s/commands/cluster_hello_cmd.cpp
+++ b/src/mongo/s/commands/cluster_hello_cmd.cpp
@@ -133,12 +133,6 @@ public:
         // "hello" is exempt from error code rewrites.
         rpc::RewriteStateChangeErrors::setEnabled(opCtx, false);
 
-        // Negotiate compressors before logging metadata so we can include the result in the log
-        // line.
-        auto result = replyBuilder->getBodyBuilder();
-        MessageCompressorManager::forSession(opCtx->getClient()->session())
-            .serverNegotiate(cmd.getCompression(), &result);
-
         auto client = opCtx->getClient();
         if (ClientMetadata::tryFinalize(client)) {
             audit::logClientMetadata(client);
@@ -172,6 +166,7 @@ public:
                     !clientTopologyVersion && !maxAwaitTimeMS);
         }
 
+        auto result = replyBuilder->getBodyBuilder();
         const auto* mongosTopCoord = MongosTopologyCoordinator::get(opCtx);
 
         auto mongosHelloResponse =
@@ -224,6 +219,9 @@ public:
             sp->append(opCtx, result, kAutomationServiceDescriptorFieldName);
         }
 
+        MessageCompressorManager::forSession(opCtx->getClient()->session())
+            .serverNegotiate(cmd.getCompression(), &result);
+
         if (opCtx->isExhaust()) {
             LOGV2_DEBUG(23872, 3, "Using exhaust for hello protocol");
 
diff --git a/src/mongo/s/commands/cluster_index_filter_cmd.cpp b/src/mongo/s/commands/cluster_index_filter_cmd.cpp
index 48aec39e5cb..f6c5bd37777 100644
--- a/src/mongo/s/commands/cluster_index_filter_cmd.cpp
+++ b/src/mongo/s/commands/cluster_index_filter_cmd.cpp
@@ -104,9 +104,7 @@ public:
             ReadPreferenceSetting::get(opCtx),
             Shard::RetryPolicy::kIdempotent,
             query,
-            CollationSpec::kSimpleSpec,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            CollationSpec::kSimpleSpec);
 
         // Sort shard responses by shard id.
         std::sort(shardResponses.begin(),
diff --git a/src/mongo/s/commands/cluster_map_reduce_agg.cpp b/src/mongo/s/commands/cluster_map_reduce_agg.cpp
index 746ba39c7bc..52a61ab9325 100644
--- a/src/mongo/s/commands/cluster_map_reduce_agg.cpp
+++ b/src/mongo/s/commands/cluster_map_reduce_agg.cpp
@@ -187,7 +187,6 @@ bool runAggregationMapReduce(OperationContext* opCtx,
                                                                cm,
                                                                involvedNamespaces,
                                                                false,   // hasChangeStream
-                                                               false,   // startsWithDocuments
                                                                true,    // allowedToPassthrough
                                                                false);  // perShardCursor
     try {
@@ -231,15 +230,14 @@ bool runAggregationMapReduce(OperationContext* opCtx,
                     namespaces,
                     privileges,
                     &tempResults,
-                    false,    // hasChangeStream
-                    false));  // startsWithDocuments
+                    false));  // hasChangeStream
                 break;
             }
 
             case cluster_aggregation_planner::AggregationTargeter::TargetingPolicy::
                 kSpecificShardOnly: {
                 // It should not be possible to pass $_passthroughToShard to a map reduce command.
-                MONGO_UNREACHABLE_TASSERT(6273805);
+                MONGO_UNREACHABLE_TASSERT(6273803);
             }
         }
     } catch (DBException& e) {
diff --git a/src/mongo/s/commands/cluster_move_range_cmd.cpp b/src/mongo/s/commands/cluster_move_range_cmd.cpp
index fd2f77ea9f5..c06ca4a5c47 100644
--- a/src/mongo/s/commands/cluster_move_range_cmd.cpp
+++ b/src/mongo/s/commands/cluster_move_range_cmd.cpp
@@ -100,7 +100,7 @@ public:
             uassert(ErrorCodes::Unauthorized,
                     "Unauthorized",
                     AuthorizationSession::get(opCtx->getClient())
-                        ->isAuthorizedForActionsOnResource(ResourcePattern::forExactNamespace(ns()),
+                        ->isAuthorizedForActionsOnResource(ResourcePattern::forClusterResource(),
                                                            ActionType::moveChunk));
         }
     };
diff --git a/src/mongo/s/commands/cluster_plan_cache_clear_cmd.cpp b/src/mongo/s/commands/cluster_plan_cache_clear_cmd.cpp
index e3411fbda2c..96499720ea6 100644
--- a/src/mongo/s/commands/cluster_plan_cache_clear_cmd.cpp
+++ b/src/mongo/s/commands/cluster_plan_cache_clear_cmd.cpp
@@ -110,9 +110,7 @@ bool ClusterPlanCacheClearCmd::run(OperationContext* opCtx,
         ReadPreferenceSetting::get(opCtx),
         Shard::RetryPolicy::kIdempotent,
         query,
-        CollationSpec::kSimpleSpec,
-        boost::none /*letParameters*/,
-        boost::none /*runtimeConstants*/);
+        CollationSpec::kSimpleSpec);
 
     // Sort shard responses by shard id.
     std::sort(shardResponses.begin(),
diff --git a/src/mongo/s/commands/cluster_profile_cmd.cpp b/src/mongo/s/commands/cluster_profile_cmd.cpp
index 022b44011c0..c2564c19b1d 100644
--- a/src/mongo/s/commands/cluster_profile_cmd.cpp
+++ b/src/mongo/s/commands/cluster_profile_cmd.cpp
@@ -33,7 +33,6 @@
 #include "mongo/db/commands.h"
 #include "mongo/db/commands/profile_common.h"
 #include "mongo/db/commands/profile_gen.h"
-#include "mongo/db/commands/set_profiling_filter_globally_cmd.h"
 #include "mongo/db/profile_filter_impl.h"
 
 namespace mongo {
@@ -54,6 +53,7 @@ protected:
         OperationContext* opCtx,
         const std::string& dbName,
         const ProfileCmdRequest& request) const final {
+        invariant(!opCtx->lockState()->isW());
 
         const auto profilingLevel = request.getCommandParameter();
 
@@ -85,7 +85,5 @@ protected:
 
 } profileCmd;
 
-SetProfilingFilterGloballyCmd setProfilingFilterGloballyCmd;
-
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/s/commands/cluster_rename_collection_cmd.cpp b/src/mongo/s/commands/cluster_rename_collection_cmd.cpp
index a5c3d9d385c..4d4d88907a6 100644
--- a/src/mongo/s/commands/cluster_rename_collection_cmd.cpp
+++ b/src/mongo/s/commands/cluster_rename_collection_cmd.cpp
@@ -32,7 +32,6 @@
 #include "mongo/platform/basic.h"
 
 #include "mongo/db/auth/authorization_session.h"
-#include "mongo/db/catalog/collection_uuid_mismatch_info.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/commands/rename_collection_common.h"
 #include "mongo/db/commands/rename_collection_gen.h"
@@ -75,21 +74,6 @@ public:
                     "Can't rename a collection to itself",
                     fromNss != toNss);
 
-            if (fromNss.isTimeseriesBucketsCollection()) {
-                uassert(
-                    ErrorCodes::IllegalOperation,
-                    "Renaming system.buckets collections is not allowed",
-                    AuthorizationSession::get(opCtx->getClient())
-                        ->isAuthorizedForActionsOnResource(ResourcePattern::forClusterResource(),
-                                                           ActionType::setUserWriteBlockMode));
-
-                uassert(ErrorCodes::IllegalOperation,
-                        str::stream()
-                            << "Cannot rename time-series buckets collection {" << fromNss.ns()
-                            << "} to a non-time-series buckets namespace {" << toNss.ns() << "}",
-                        toNss.isTimeseriesBucketsCollection());
-            }
-
             RenameCollectionRequest renameCollReq(request().getTo());
             renameCollReq.setStayTemp(request().getStayTemp());
             renameCollReq.setExpectedSourceUUID(request().getCollectionUUID());
@@ -106,22 +90,9 @@ public:
             ShardsvrRenameCollection renameCollRequest(fromNss);
             renameCollRequest.setDbName(fromNss.db());
             renameCollRequest.setRenameCollectionRequest(renameCollReq);
-            renameCollRequest.setAllowEncryptedCollectionRename(
-                AuthorizationSession::get(opCtx->getClient())
-                    ->isAuthorizedForActionsOnResource(ResourcePattern::forClusterResource(),
-                                                       ActionType::setUserWriteBlockMode));
 
             auto catalogCache = Grid::get(opCtx)->catalogCache();
-            auto swDbInfo = Grid::get(opCtx)->catalogCache()->getDatabase(opCtx, fromNss.db());
-            if (swDbInfo == ErrorCodes::NamespaceNotFound) {
-                uassert(CollectionUUIDMismatchInfo(fromNss.db().toString(),
-                                                   *request().getCollectionUUID(),
-                                                   fromNss.coll().toString(),
-                                                   boost::none),
-                        "Database does not exist",
-                        !request().getCollectionUUID());
-            }
-            const auto dbInfo = uassertStatusOK(swDbInfo);
+            const auto dbInfo = uassertStatusOK(catalogCache->getDatabase(opCtx, fromNss.db()));
             auto cri = uassertStatusOK(catalogCache->getCollectionRoutingInfo(opCtx, fromNss));
 
             auto shard = uassertStatusOK(
diff --git a/src/mongo/s/commands/cluster_set_free_monitoring_cmd.cpp b/src/mongo/s/commands/cluster_set_free_monitoring_cmd.cpp
new file mode 100644
index 00000000000..d54cd80b219
--- /dev/null
+++ b/src/mongo/s/commands/cluster_set_free_monitoring_cmd.cpp
@@ -0,0 +1,75 @@
+/**
+ *    Copyright (C) 2018-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#include "mongo/platform/basic.h"
+
+#include "mongo/db/auth/authorization_session.h"
+#include "mongo/db/commands.h"
+
+namespace mongo {
+namespace {
+
+class ClusterSetFreeMonitoring : public BasicCommand {
+public:
+    ClusterSetFreeMonitoring() : BasicCommand("setFreeMonitoring") {}
+
+    AllowedOnSecondary secondaryAllowed(ServiceContext*) const final {
+        return AllowedOnSecondary::kNever;
+    }
+
+    bool supportsWriteConcern(const BSONObj& cmd) const final {
+        return false;
+    }
+
+    std::string help() const final {
+        return "setFreeMonitoring command must be run against mongod instances";
+    }
+
+    Status checkAuthForCommand(Client* client,
+                               const std::string& dbname,
+                               const BSONObj& cmdObj) const final {
+        if (!AuthorizationSession::get(client)->isAuthorizedForActionsOnResource(
+                ResourcePattern::forClusterResource(), ActionType::setFreeMonitoring)) {
+            return Status(ErrorCodes::Unauthorized, "Unauthorized");
+        }
+        return Status::OK();
+    }
+
+    bool run(OperationContext* opCtx,
+             const std::string& dbname,
+             const BSONObj& cmdObj,
+             BSONObjBuilder& result) final {
+        uasserted(ErrorCodes::CommandFailed, help());
+        return true;
+    }
+
+} clusterSetFreeMonitoring;
+
+}  // namespace
+}  // namespace mongo
diff --git a/src/mongo/s/commands/cluster_set_index_commit_quorum_cmd.cpp b/src/mongo/s/commands/cluster_set_index_commit_quorum_cmd.cpp
index f494e41a6a6..8727a9da078 100644
--- a/src/mongo/s/commands/cluster_set_index_commit_quorum_cmd.cpp
+++ b/src/mongo/s/commands/cluster_set_index_commit_quorum_cmd.cpp
@@ -117,10 +117,8 @@ public:
                 opCtx, this, CommandHelpers::filterCommandRequestForPassthrough(cmdObj)),
             ReadPreferenceSetting::get(opCtx),
             Shard::RetryPolicy::kNotIdempotent,
-            BSONObj() /*query*/,
-            BSONObj() /*collation*/,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            BSONObj() /* query */,
+            BSONObj() /* collation */);
 
         std::string errmsg;
         const bool ok =
diff --git a/src/mongo/s/commands/cluster_validate_cmd.cpp b/src/mongo/s/commands/cluster_validate_cmd.cpp
index 285d23fc29d..52285704516 100644
--- a/src/mongo/s/commands/cluster_validate_cmd.cpp
+++ b/src/mongo/s/commands/cluster_validate_cmd.cpp
@@ -84,10 +84,8 @@ public:
                 opCtx, this, CommandHelpers::filterCommandRequestForPassthrough(cmdObj)),
             ReadPreferenceSetting::get(opCtx),
             Shard::RetryPolicy::kIdempotent,
-            {} /*query*/,
-            {} /*collation*/,
-            boost::none /*letParameters*/,
-            boost::none /*runtimeConstants*/);
+            {},
+            {});
 
         Status firstFailedShardStatus = Status::OK();
         bool isValid = true;
diff --git a/src/mongo/s/commands/cluster_write_cmd.cpp b/src/mongo/s/commands/cluster_write_cmd.cpp
index 8590832acc6..10d04ba0b82 100644
--- a/src/mongo/s/commands/cluster_write_cmd.cpp
+++ b/src/mongo/s/commands/cluster_write_cmd.cpp
@@ -145,6 +145,11 @@ boost::optional<WouldChangeOwningShardInfo> getWouldChangeOwningShardErrorInfo(
 void handleWouldChangeOwningShardErrorRetryableWrite(OperationContext* opCtx,
                                                      BatchedCommandRequest* request,
                                                      BatchedCommandResponse* response) {
+    // Strip write concern because this command will be sent as part of a
+    // transaction and the write concern has already been loaded onto the opCtx and
+    // will be picked up by the transaction API.
+    request->unsetWriteConcern();
+
     // Strip runtime constants because they will be added again when the API sends this command
     // through the service entry point.
     request->unsetLegacyRuntimeConstants();
@@ -313,6 +318,11 @@ bool handleWouldChangeOwningShardError(OperationContext* opCtx,
                 auto& readConcernArgs = repl::ReadConcernArgs::get(opCtx);
                 readConcernArgs = repl::ReadConcernArgs(repl::ReadConcernLevel::kLocalReadConcern);
 
+                // Ensure the retried operation does not include WC inside the transaction.  The
+                // transaction commit will still use the WC, because it uses the WC from the opCtx
+                // (which has been set previously in Strategy).
+                request->unsetWriteConcern();
+
                 documentShardKeyUpdateUtil::startTransactionForShardKeyUpdate(opCtx);
                 // Clear the error details from the response object before sending the write again
                 response->unsetErrDetails();
@@ -497,6 +507,29 @@ bool ClusterWriteCmd::InvocationBase::runImpl(OperationContext* opCtx,
     BatchWriteExecStats stats;
     BatchedCommandResponse response;
 
+    // The batched request will only have WC if it was supplied by the client. Otherwise, the
+    // batched request should use the WC from the opCtx.
+    if (!batchedRequest.hasWriteConcern()) {
+        if (opCtx->getWriteConcern().usedDefaultConstructedWC) {
+            // Pass writeConcern: {}, rather than {w: 1, wtimeout: 0}, so as to not override the
+            // configsvr w:majority upconvert.
+            batchedRequest.setWriteConcern(BSONObj());
+        } else {
+            batchedRequest.setWriteConcern(opCtx->getWriteConcern().toBSON());
+        }
+    }
+
+    // Write ops are never allowed to have writeConcern inside transactions. Normally
+    // disallowing WC on non-terminal commands in a transaction is handled earlier, during
+    // command dispatch. However, if this is a regular write operation being automatically
+    // retried inside a transaction (such as changing a document's shard key across shards),
+    // then batchedRequest will have a writeConcern (added by the if() above) from when it was
+    // initially run outside a transaction. Thus it's necessary to unconditionally clear the
+    // writeConcern when in a transaction.
+    if (TransactionRouter::get(opCtx)) {
+        batchedRequest.unsetWriteConcern();
+    }
+
     cluster::write(opCtx, batchedRequest, &stats, &response);
 
     bool updatedShardKey = false;
@@ -522,17 +555,22 @@ bool ClusterWriteCmd::InvocationBase::runImpl(OperationContext* opCtx,
 
     // TODO: increase opcounters by more than one
     auto& debug = CurOp::get(opCtx)->debug();
+    auto catalogCache = Grid::get(opCtx)->catalogCache();
     switch (_batchedRequest.getBatchType()) {
         case BatchedCommandRequest::BatchType_Insert:
             for (size_t i = 0; i < numAttempts; ++i) {
                 globalOpCounters.gotInsert();
             }
+            catalogCache->checkAndRecordOperationBlockedByRefresh(opCtx,
+                                                                  mongo::LogicalOp::opInsert);
             debug.additiveMetrics.ninserted = response.getN();
             break;
         case BatchedCommandRequest::BatchType_Update:
             for (size_t i = 0; i < numAttempts; ++i) {
                 globalOpCounters.gotUpdate();
             }
+            catalogCache->checkAndRecordOperationBlockedByRefresh(opCtx,
+                                                                  mongo::LogicalOp::opUpdate);
 
             // The response.getN() count is the sum of documents matched and upserted.
             if (response.isUpsertDetailsSet()) {
@@ -565,6 +603,8 @@ bool ClusterWriteCmd::InvocationBase::runImpl(OperationContext* opCtx,
             for (size_t i = 0; i < numAttempts; ++i) {
                 globalOpCounters.gotDelete();
             }
+            catalogCache->checkAndRecordOperationBlockedByRefresh(opCtx,
+                                                                  mongo::LogicalOp::opDelete);
             debug.additiveMetrics.ndeleted = response.getN();
             break;
     }
diff --git a/src/mongo/s/commands/strategy.cpp b/src/mongo/s/commands/strategy.cpp
index e12b3385a13..13d061e9e6d 100644
--- a/src/mongo/s/commands/strategy.cpp
+++ b/src/mongo/s/commands/strategy.cpp
@@ -426,6 +426,14 @@ public:
 
     explicit RunInvocation(ParseAndRunCommand* parc) : _parc(parc) {}
 
+    ~RunInvocation() {
+        if (!_shouldAffectCommandCounter)
+            return;
+        auto opCtx = _parc->_rec->getOpCtx();
+        Grid::get(opCtx)->catalogCache()->checkAndRecordOperationBlockedByRefresh(
+            opCtx, mongo::LogicalOp::opCommand);
+    }
+
     Future<void> run();
 
 private:
@@ -434,6 +442,7 @@ private:
     ParseAndRunCommand* const _parc;
 
     boost::optional<RouterOperationContextSession> _routerSession;
+    bool _shouldAffectCommandCounter = false;
 };
 
 /*
@@ -698,53 +707,31 @@ Status ParseAndRunCommand::RunInvocation::_setup() {
         (opCtx->getClient()->session() &&
          (opCtx->getClient()->session()->getTags() & transport::Session::kInternalClient));
 
-    bool canApplyDefaultWC = supportsWriteConcern &&
+    if (supportsWriteConcern && !clientSuppliedWriteConcern &&
         (!TransactionRouter::get(opCtx) || isTransactionCommand(_parc->_commandName)) &&
-        !opCtx->getClient()->isInDirectClient();
-
-    if (canApplyDefaultWC) {
-        auto getDefaultWC = ([&]() {
-            auto rwcDefaults =
+        !opCtx->getClient()->isInDirectClient()) {
+        if (isInternalClient) {
+            uassert(
+                5569900,
+                "received command without explicit writeConcern on an internalClient connection {}"_format(
+                    redact(request.body.toString())),
+                request.body.hasField(WriteConcernOptions::kWriteConcernField));
+        } else {
+            // This command is not from a DBDirectClient or internal client, and supports WC, but
+            // wasn't given one - so apply the default, if there is one.
+            const auto rwcDefaults =
                 ReadWriteConcernDefaults::get(opCtx->getServiceContext()).getDefault(opCtx);
-            auto wcDefault = rwcDefaults.getDefaultWriteConcern();
-            const auto defaultWriteConcernSource = rwcDefaults.getDefaultWriteConcernSource();
-            customDefaultWriteConcernWasApplied = defaultWriteConcernSource &&
-                defaultWriteConcernSource == DefaultWriteConcernSourceEnum::kGlobal;
-            return wcDefault;
-        });
-
-        if (!clientSuppliedWriteConcern) {
-            if (isInternalClient) {
-                uassert(
-                    5569900,
-                    "received command without explicit writeConcern on an internalClient connection {}"_format(
-                        redact(request.body.toString())),
-                    request.body.hasField(WriteConcernOptions::kWriteConcernField));
-            } else {
-                // This command is not from a DBDirectClient or internal client, and supports WC,
-                // but wasn't given one - so apply the default, if there is one.
-                const auto wcDefault = getDefaultWC();
-                // Default WC can be 'boost::none' if the implicit default is used and set to 'w:1'.
-                if (wcDefault) {
-                    _parc->_wc = *wcDefault;
-                    LOGV2_DEBUG(22766,
-                                2,
-                                "Applying default writeConcern on command",
-                                "command"_attr = request.getCommandName(),
-                                "writeConcern"_attr = *wcDefault);
-                }
-            }
-        }
-        // Client supplied a write concern object without 'w' field.
-        else if (_parc->_wc->isExplicitWithoutWField()) {
-            const auto wcDefault = getDefaultWC();
-            // Default WC can be 'boost::none' if the implicit default is used and set to 'w:1'.
-            if (wcDefault) {
-                clientSuppliedWriteConcern = false;
-                _parc->_wc->w = wcDefault->w;
-                if (_parc->_wc->syncMode == WriteConcernOptions::SyncMode::UNSET) {
-                    _parc->_wc->syncMode = wcDefault->syncMode;
-                }
+            if (const auto wcDefault = rwcDefaults.getDefaultWriteConcern()) {
+                _parc->_wc = *wcDefault;
+                const auto defaultWriteConcernSource = rwcDefaults.getDefaultWriteConcernSource();
+                customDefaultWriteConcernWasApplied = defaultWriteConcernSource &&
+                    defaultWriteConcernSource == DefaultWriteConcernSourceEnum::kGlobal;
+                LOGV2_DEBUG(22766,
+                            2,
+                            "Applying default writeConcern on {command} of {writeConcern}",
+                            "Applying default writeConcern on command",
+                            "command"_attr = request.getCommandName(),
+                            "writeConcern"_attr = *wcDefault);
             }
         }
     }
@@ -911,6 +898,7 @@ Status ParseAndRunCommand::RunInvocation::_setup() {
 
     if (command->shouldAffectCommandCounter()) {
         globalOpCounters.gotCommand();
+        _shouldAffectCommandCounter = true;
     }
 
     return Status::OK();
@@ -1048,21 +1036,10 @@ void ParseAndRunCommand::RunAndRetry::_onNeedRetargetting(Status& status) {
 
     auto opCtx = _parc->_rec->getOpCtx();
     const auto staleNs = staleInfo->getNss();
-    const auto& originalNs = _parc->_invocation->ns();
     auto catalogCache = Grid::get(opCtx)->catalogCache();
     catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
         staleNs, staleInfo->getVersionWanted(), staleInfo->getShardId());
 
-    if ((staleNs.isTimeseriesBucketsCollection() || originalNs.isTimeseriesBucketsCollection()) &&
-        staleNs != originalNs) {
-        // A timeseries might've been created, so we need to invalidate the original namespace
-        // version.
-        Grid::get(opCtx)
-            ->catalogCache()
-            ->invalidateShardOrEntireCollectionEntryForShardedCollection(
-                originalNs, boost::none, staleInfo->getShardId());
-    }
-
     catalogCache->setOperationShouldBlockBehindCatalogCacheRefresh(opCtx, true);
 
     _checkRetryForTransaction(status);
@@ -1193,13 +1170,6 @@ public:
     Future<DbResponse> run();
 
 private:
-    std::string _getDatabaseStringForLogging() const try {
-        // `getDatabase` throws if the request doesn't have a '$db' field.
-        return _rec->getRequest().getDatabase().toString();
-    } catch (const DBException& ex) {
-        return ex.toString();
-    }
-
     void _parseMessage();
 
     Future<void> _execute();
@@ -1242,7 +1212,7 @@ Future<void> ClientCommand::_execute() {
                 3,
                 "Command begin db: {db} msg id: {headerId}",
                 "Command begin",
-                "db"_attr = _getDatabaseStringForLogging(),
+                "db"_attr = _rec->getRequest().getDatabase().toString(),
                 "headerId"_attr = _rec->getMessage().header().getId());
 
     return future_util::makeState<ParseAndRunCommand>(_rec, _errorBuilder)
@@ -1252,7 +1222,7 @@ Future<void> ClientCommand::_execute() {
                         3,
                         "Command end db: {db} msg id: {headerId}",
                         "Command end",
-                        "db"_attr = _getDatabaseStringForLogging(),
+                        "db"_attr = _rec->getRequest().getDatabase().toString(),
                         "headerId"_attr = _rec->getMessage().header().getId());
         })
         .tapError([this](Status status) {
@@ -1261,7 +1231,7 @@ Future<void> ClientCommand::_execute() {
                 1,
                 "Exception thrown while processing command on {db} msg id: {headerId} {error}",
                 "Exception thrown while processing command",
-                "db"_attr = _getDatabaseStringForLogging(),
+                "db"_attr = _rec->getRequest().getDatabase().toString(),
                 "headerId"_attr = _rec->getMessage().header().getId(),
                 "error"_attr = redact(status));
 
diff --git a/src/mongo/s/commands/strategy.h b/src/mongo/s/commands/strategy.h
index 73916229f7f..1e04130f657 100644
--- a/src/mongo/s/commands/strategy.h
+++ b/src/mongo/s/commands/strategy.h
@@ -41,8 +41,8 @@ public:
     /**
      * Executes a command from either OP_QUERY or OP_MSG wire protocols.
      *
-     * Catches StaleConfig errors and retries the command automatically after refreshing the
-     * metadata for the failing namespace.
+     * Catches StaleConfigException errors and retries the command automatically after refreshing
+     * the metadata for the failing namespace.
      */
     static Future<DbResponse> clientCommand(std::shared_ptr<RequestExecutionContext> rec);
 };
diff --git a/src/mongo/s/concurrency/locker_mongos.h b/src/mongo/s/concurrency/locker_mongos.h
index 61055d26595..f4c3d72894e 100644
--- a/src/mongo/s/concurrency/locker_mongos.h
+++ b/src/mongo/s/concurrency/locker_mongos.h
@@ -115,10 +115,7 @@ public:
         MONGO_UNREACHABLE;
     }
 
-    void lockRSTLComplete(OperationContext* opCtx,
-                          LockMode mode,
-                          Date_t deadline,
-                          const LockTimeoutCallback& onTimeout) override {
+    void lockRSTLComplete(OperationContext* opCtx, LockMode mode, Date_t deadline) override {
         MONGO_UNREACHABLE;
     }
 
@@ -168,7 +165,7 @@ public:
         return boost::none;
     }
 
-    void saveLockStateAndUnlock(LockSnapshot* stateOut) override {
+    bool saveLockStateAndUnlock(LockSnapshot* stateOut) override {
         MONGO_UNREACHABLE;
     }
 
@@ -180,7 +177,7 @@ public:
         MONGO_UNREACHABLE;
     }
 
-    void releaseWriteUnitOfWorkAndUnlock(LockSnapshot* stateOut) override {
+    bool releaseWriteUnitOfWorkAndUnlock(LockSnapshot* stateOut) override {
         MONGO_UNREACHABLE;
     }
 
@@ -254,10 +251,6 @@ public:
     bool isGlobalLockedRecursively() override {
         return false;
     }
-
-    bool canSaveLockState() override {
-        return false;
-    }
 };
 
 }  // namespace mongo
diff --git a/src/mongo/s/config_server_catalog_cache_loader.cpp b/src/mongo/s/config_server_catalog_cache_loader.cpp
index 84cc73b987a..3910e1e4c88 100644
--- a/src/mongo/s/config_server_catalog_cache_loader.cpp
+++ b/src/mongo/s/config_server_catalog_cache_loader.cpp
@@ -114,10 +114,6 @@ void ConfigServerCatalogCacheLoader::onStepUp() {
     MONGO_UNREACHABLE;
 }
 
-void ConfigServerCatalogCacheLoader::onReplicationRollback() {
-    MONGO_UNREACHABLE;
-}
-
 void ConfigServerCatalogCacheLoader::shutDown() {
     _executor->shutdown();
     _executor->join();
diff --git a/src/mongo/s/config_server_catalog_cache_loader.h b/src/mongo/s/config_server_catalog_cache_loader.h
index 86af7a6b14b..8c1384946f8 100644
--- a/src/mongo/s/config_server_catalog_cache_loader.h
+++ b/src/mongo/s/config_server_catalog_cache_loader.h
@@ -46,7 +46,6 @@ public:
     void initializeReplicaSetRole(bool isPrimary) override;
     void onStepDown() override;
     void onStepUp() override;
-    void onReplicationRollback() override;
     void shutDown() override;
     void notifyOfCollectionVersionUpdate(const NamespaceString& nss) override;
     void waitForCollectionFlush(OperationContext* opCtx, const NamespaceString& nss) override;
diff --git a/src/mongo/s/database_version.idl b/src/mongo/s/database_version.idl
index 68134191b6a..9b073f5a34e 100644
--- a/src/mongo/s/database_version.idl
+++ b/src/mongo/s/database_version.idl
@@ -48,8 +48,7 @@ structs:
                 optional: true
             timestamp:
                 type: timestamp
-                description: "Unique identifier to distinguish major events in the lifetime of a
-                   database, such as create/drop and change of primary."
+                description: "Uniquely identifies to distinguish different incarnations of this database."
             lastMod:
                 type: int
                 description: "an integer which is bumped whenever the database's primary shard changes"
diff --git a/src/mongo/s/mongod_and_mongos_server_parameters.idl b/src/mongo/s/mongod_and_mongos_server_parameters.idl
index 0a760d967d8..9d9929174e0 100644
--- a/src/mongo/s/mongod_and_mongos_server_parameters.idl
+++ b/src/mongo/s/mongod_and_mongos_server_parameters.idl
@@ -69,13 +69,3 @@ server_parameters:
     cpp_vartype: bool
     cpp_varname: "gEnableFinerGrainedCatalogCacheRefresh"
     default: false
-
-  routingTableCacheChunkBucketSize:
-    description: >-
-        Size of the routing table cache buckets used to implement chunk grouping optimization.
-    set_at: [ startup ]
-    cpp_vartype: long long
-    cpp_varname: "gRoutingTableCacheChunkBucketSize"
-    default: 500
-    validator:
-      gte: 0
diff --git a/src/mongo/s/mongos_main.cpp b/src/mongo/s/mongos_main.cpp
index 665f3fe08d4..0504b714aec 100644
--- a/src/mongo/s/mongos_main.cpp
+++ b/src/mongo/s/mongos_main.cpp
@@ -127,10 +127,6 @@
 #include "mongo/util/text.h"
 #include "mongo/util/version.h"
 
-#ifdef __linux__
-#include <sys/prctl.h>
-#endif
-
 namespace mongo {
 
 using logv2::LogComponent;
@@ -316,10 +312,7 @@ void cleanupTask(const ShutdownTaskArgs& shutdownArgs) {
 
         ReplicaSetMonitor::shutdown();
 
-        {
-            stdx::lock_guard lg(client);
-            opCtx->setIsExecutingShutdown();
-        }
+        opCtx->setIsExecutingShutdown();
 
         if (serviceContext) {
             serviceContext->setKillAllOperations();
@@ -348,7 +341,6 @@ void cleanupTask(const ShutdownTaskArgs& shutdownArgs) {
         }
 
         if (auto pool = Grid::get(opCtx)->getExecutorPool()) {
-            LOGV2_OPTIONS(7698300, {LogComponent::kSharding}, "Shutting down the ExecutorPool");
             pool->shutdownAndJoin();
         }
 
@@ -357,13 +349,6 @@ void cleanupTask(const ShutdownTaskArgs& shutdownArgs) {
         }
 
         if (Grid::get(serviceContext)->isShardingInitialized()) {
-            // The CatalogCache must be shuted down before shutting down the CatalogCacheLoader as
-            // the CatalogCache may try to schedule work on CatalogCacheLoader and fail.
-            LOGV2_OPTIONS(7698301, {LogComponent::kSharding}, "Shutting down the CatalogCache");
-            Grid::get(serviceContext)->catalogCache()->shutDownAndJoin();
-
-            LOGV2_OPTIONS(
-                7698302, {LogComponent::kSharding}, "Shutting down the CatalogCacheLoader");
             CatalogCacheLoader::get(serviceContext).shutDown();
         }
 
@@ -860,18 +845,6 @@ std::unique_ptr<AuthzManagerExternalState> createAuthzManagerExternalStateMongos
     return std::make_unique<AuthzManagerExternalStateMongos>();
 }
 
-void disableMongosTHPUnderTestingEnvironment() {
-#ifdef __linux__
-    if (TestingProctor::instance().isEnabled()) {
-        if (prctl(PR_SET_THP_DISABLE, 1, 0, 0, 0) == -1) {
-            LOGV2_WARNING(8751802, "Could not disable THP on mongos");
-        } else {
-            LOGV2_INFO(8751803, "Successfully disabled THP on mongos");
-        }
-    }
-#endif
-}
-
 ExitCode main(ServiceContext* serviceContext) {
     serviceContext->setFastClockSource(FastClockSourceFactory::create(Milliseconds{10}));
 
@@ -946,8 +919,6 @@ ExitCode mongos_main(int argc, char* argv[]) {
         return EXIT_ABRUPT;
     }
 
-    disableMongosTHPUnderTestingEnvironment();
-
     try {
         auto serviceContextHolder = ServiceContext::make();
         serviceContextHolder->registerClientObserver(
diff --git a/src/mongo/s/mongos_options.cpp b/src/mongo/s/mongos_options.cpp
index 8b995415368..d333d1f7fc2 100644
--- a/src/mongo/s/mongos_options.cpp
+++ b/src/mongo/s/mongos_options.cpp
@@ -115,6 +115,13 @@ Status storeMongosOptions(const moe::Environment& params) {
         return ret;
     }
 
+    if (params.count("net.port")) {
+        int port = params["net.port"].as<int>();
+        if (port <= 0 || port > 65535) {
+            return Status(ErrorCodes::BadValue, "error: port number must be between 1 and 65535");
+        }
+    }
+
     if (params.count("security.javascriptEnabled")) {
         mongosGlobalParams.scriptingEnabled = params["security.javascriptEnabled"].as<bool>();
     }
diff --git a/src/mongo/s/multi_statement_transaction_requests_sender.cpp b/src/mongo/s/multi_statement_transaction_requests_sender.cpp
index d63b830d9a4..c62b4e97da4 100644
--- a/src/mongo/s/multi_statement_transaction_requests_sender.cpp
+++ b/src/mongo/s/multi_statement_transaction_requests_sender.cpp
@@ -40,9 +40,7 @@ namespace mongo {
 namespace {
 
 std::vector<AsyncRequestsSender::Request> attachTxnDetails(
-    OperationContext* opCtx,
-    const std::vector<AsyncRequestsSender::Request>& requests,
-    const StringData& dbName) {
+    OperationContext* opCtx, const std::vector<AsyncRequestsSender::Request>& requests) {
     auto txnRouter = TransactionRouter::get(opCtx);
     if (!txnRouter) {
         return requests;
@@ -54,7 +52,7 @@ std::vector<AsyncRequestsSender::Request> attachTxnDetails(
     for (auto request : requests) {
         newRequests.emplace_back(
             request.shardId,
-            txnRouter.attachTxnFieldsIfNeeded(opCtx, request.shardId, request.cmdObj, dbName));
+            txnRouter.attachTxnFieldsIfNeeded(opCtx, request.shardId, request.cmdObj));
     }
 
     return newRequests;
@@ -88,7 +86,7 @@ MultiStatementTransactionRequestsSender::MultiStatementTransactionRequestsSender
           opCtx,
           std::move(executor),
           dbName,
-          attachTxnDetails(opCtx, requests, dbName),
+          attachTxnDetails(opCtx, requests),
           readPreference,
           retryPolicy,
           TransactionRouterResourceYielder::makeForRemoteCommand())) {}
diff --git a/src/mongo/s/query/SConscript b/src/mongo/s/query/SConscript
index f8179e37eeb..f6f1ac53b05 100644
--- a/src/mongo/s/query/SConscript
+++ b/src/mongo/s/query/SConscript
@@ -8,17 +8,17 @@ env.Library(
     target="cluster_query",
     source=[
         "cluster_find.cpp",
-        "cluster_query_knobs.idl",
-        "store_possible_cursor.cpp",
+        'cluster_query_knobs.idl',
     ],
     LIBDEPS=[
         '$BUILD_DIR/mongo/db/commands',
+        '$BUILD_DIR/mongo/db/curop',
         '$BUILD_DIR/mongo/db/curop_failpoint_helpers',
         '$BUILD_DIR/mongo/db/query/query_common',
-        '$BUILD_DIR/mongo/db/query/query_stats/query_stats',
         '$BUILD_DIR/mongo/s/sharding_router_api',
         "cluster_client_cursor",
         "cluster_cursor_cleanup_job",
+        "store_possible_cursor",
     ],
     LIBDEPS_PRIVATE=[
         '$BUILD_DIR/mongo/db/catalog/collection_uuid_mismatch_info',
@@ -37,14 +37,12 @@ env.Library(
         '$BUILD_DIR/mongo/db/pipeline/pipeline',
         '$BUILD_DIR/mongo/db/pipeline/process_interface/mongos_process_interface',
         '$BUILD_DIR/mongo/db/pipeline/sharded_agg_helpers',
-        '$BUILD_DIR/mongo/db/query/query_shape/query_shape',
         '$BUILD_DIR/mongo/db/views/view_catalog_helpers',
         '$BUILD_DIR/mongo/db/views/views',
         '$BUILD_DIR/mongo/s/query/cluster_client_cursor',
         'cluster_query',
     ],
     LIBDEPS_PRIVATE=[
-        '$BUILD_DIR/mongo/db/catalog/collection_uuid_mismatch_info',
         '$BUILD_DIR/mongo/db/timeseries/timeseries_options',
     ]
 )
@@ -94,11 +92,24 @@ env.Library(
     ],
     LIBDEPS_PRIVATE=[
         '$BUILD_DIR/mongo/db/catalog/collection_uuid_mismatch_info',
-        '$BUILD_DIR/mongo/executor/async_multicaster',
     ]
 )
 
 env.Library(
+    target="store_possible_cursor",
+    source=[
+        "store_possible_cursor.cpp"
+    ],
+    LIBDEPS=[
+        "$BUILD_DIR/mongo/base",
+        "$BUILD_DIR/mongo/db/curop",
+        "$BUILD_DIR/mongo/db/query/command_request_response",
+        "cluster_client_cursor",
+        "cluster_cursor_manager",
+    ],
+)
+
+env.Library(
     target="cluster_cursor_manager",
     source=[
         "cluster_cursor_manager.cpp",
@@ -107,12 +118,12 @@ env.Library(
         '$BUILD_DIR/mongo/base',
         '$BUILD_DIR/mongo/db/auth/auth',
         '$BUILD_DIR/mongo/db/auth/authprivilege',
+        '$BUILD_DIR/mongo/db/curop',
         '$BUILD_DIR/mongo/db/generic_cursor',
         '$BUILD_DIR/mongo/db/kill_sessions',
         '$BUILD_DIR/mongo/db/logical_session_cache',
         '$BUILD_DIR/mongo/db/logical_session_id',
         '$BUILD_DIR/mongo/db/query/query_knobs',
-        '$BUILD_DIR/mongo/db/query/query_stats/query_stats',
     ],
 )
 
@@ -159,7 +170,7 @@ env.CppUnitTest(
         "cluster_aggregate",
         "cluster_client_cursor",
         "cluster_cursor_manager",
-        "cluster_query",
         "router_exec_stage",
+        "store_possible_cursor",
     ],
 )
diff --git a/src/mongo/s/query/async_results_merger.cpp b/src/mongo/s/query/async_results_merger.cpp
index 50fb6310888..363e151fbfd 100644
--- a/src/mongo/s/query/async_results_merger.cpp
+++ b/src/mongo/s/query/async_results_merger.cpp
@@ -846,8 +846,7 @@ void AsyncResultsMerger::_scheduleKillCursors(WithLock, OperationContext* opCtx)
     invariant(_killCompleteInfo);
 
     for (const auto& remote : _remotes) {
-        if ((remote.status.isOK() || remote.status == ErrorCodes::MaxTimeMSExpired) &&
-            remote.cursorId && !remote.exhausted()) {
+        if (remote.status.isOK() && remote.cursorId && !remote.exhausted()) {
             BSONObj cmdObj =
                 KillCursorsCommandRequest(_params.getNss(), {remote.cursorId}).toBSON(BSONObj{});
 
diff --git a/src/mongo/s/query/async_results_merger_params.idl b/src/mongo/s/query/async_results_merger_params.idl
index 5382c9cc718..2b5857e6c9b 100644
--- a/src/mongo/s/query/async_results_merger_params.idl
+++ b/src/mongo/s/query/async_results_merger_params.idl
@@ -50,19 +50,15 @@ types:
 structs:
     RemoteCursor:
         description: A description of a cursor opened on a remote server.
-        query_shape_component: true
         fields:
             shardId:
                 type: string
                 description: The shardId of the shard on which the cursor resides.
-                query_shape: anonymize
             hostAndPort:
                 type: HostAndPort
                 description: The exact host (within the shard) on which the cursor resides.
-                query_shape: anonymize
             cursorResponse:
                 type: CursorResponse
-                query_shape: literal
                 description: The response after establishing a cursor on the remote shard, including
                              the first batch.
 
@@ -70,47 +66,33 @@ structs:
         description: The parameters needed to establish an AsyncResultsMerger.
         chained_structs:
             OperationSessionInfoFromClient : OperationSessionInfo
-        query_shape_component: true
         fields:
             sort:
                 type: object
                 description: The sort requested on the merging operation. Empty if there is no sort.
                 optional: true
-                query_shape: literal
             compareWholeSortKey:
                 type: bool
                 default: false
-                query_shape: literal
                 description: >-
                     When 'compareWholeSortKey' is true, $sortKey is a scalar value, rather than an
                     object. We extract the sort key {$sortKey: <value>}. The sort key pattern is
                     verified to be {$sortKey: 1}.
-            remotes:
-                type: array<RemoteCursor>
-                query_shape: literal
+            remotes: array<RemoteCursor>
             tailableMode:
                 type: TailableMode
                 optional: true
                 description: If set, the tailability mode of this cursor.
-                query_shape: parameter
             batchSize:
                 type: safeInt64
                 optional: true
                 description: The batch size for this cursor.
-                query_shape: literal
-            nss:
-                type: namespacestring
-                query_shape: custom
+            nss: namespacestring
             allowPartialResults:
                 type: bool
                 default: false
                 description: If set, error responses are ignored.
-                query_shape: parameter
             recordRemoteOpWaitTime:
                 type: bool
                 default: false
-                query_shape: parameter
-                description: >-
-                    This parameter is not used anymore but should stay for a while for backward
-                    compatibility.
-                    TODO SERVER-73120 Remove this parameter when releasing 8.0.
+                description: If set, records the total time spent waiting for remote operations to complete.
diff --git a/src/mongo/s/query/blocking_results_merger.cpp b/src/mongo/s/query/blocking_results_merger.cpp
index fc56a0d9e3b..c1a957a311f 100644
--- a/src/mongo/s/query/blocking_results_merger.cpp
+++ b/src/mongo/s/query/blocking_results_merger.cpp
@@ -42,6 +42,7 @@ BlockingResultsMerger::BlockingResultsMerger(OperationContext* opCtx,
                                              std::shared_ptr<executor::TaskExecutor> executor,
                                              std::unique_ptr<ResourceYielder> resourceYielder)
     : _tailableMode(armParams.getTailableMode().value_or(TailableModeEnum::kNormal)),
+      _recordRemoteOpWaitTime(armParams.getRecordRemoteOpWaitTime()),
       _executor(executor),
       _arm(opCtx, std::move(executor), std::move(armParams)),
       _resourceYielder(std::move(resourceYielder)) {}
@@ -145,7 +146,9 @@ StatusWith<ClusterQueryResult> BlockingResultsMerger::blockUntilNext(OperationCo
     return _arm.nextReady();
 }
 StatusWith<ClusterQueryResult> BlockingResultsMerger::next(OperationContext* opCtx) {
-    CurOp::get(opCtx)->ensureRecordRemoteOpWait();
+    if (_recordRemoteOpWaitTime) {
+        CurOp::get(opCtx)->enableRecordRemoteOpWait();
+    }
 
     // Non-tailable and tailable non-awaitData cursors always block until ready(). AwaitData
     // cursors wait for ready() only until a specified time limit is exceeded.
diff --git a/src/mongo/s/query/blocking_results_merger.h b/src/mongo/s/query/blocking_results_merger.h
index c05cecc5da8..4a368d9471a 100644
--- a/src/mongo/s/query/blocking_results_merger.h
+++ b/src/mongo/s/query/blocking_results_merger.h
@@ -118,6 +118,7 @@ private:
         const std::function<StatusWith<stdx::cv_status>()>& waitFn) noexcept;
 
     TailableModeEnum _tailableMode;
+    bool _recordRemoteOpWaitTime;
     std::shared_ptr<executor::TaskExecutor> _executor;
 
     // In a case where we have a tailable, awaitData cursor, a call to 'next()' will block waiting
diff --git a/src/mongo/s/query/cluster_aggregate.cpp b/src/mongo/s/query/cluster_aggregate.cpp
index 6374bcfd494..b3df71582da 100644
--- a/src/mongo/s/query/cluster_aggregate.cpp
+++ b/src/mongo/s/query/cluster_aggregate.cpp
@@ -27,7 +27,6 @@
  *    it in the license file.
  */
 
-#include "mongo/s/chunk_manager.h"
 #define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kCommand
 
 #include "mongo/platform/basic.h"
@@ -38,7 +37,6 @@
 
 #include "mongo/db/api_parameters.h"
 #include "mongo/db/auth/authorization_session.h"
-#include "mongo/db/catalog/collection_uuid_mismatch_info.h"
 #include "mongo/db/client.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/curop.h"
@@ -57,9 +55,6 @@
 #include "mongo/db/query/explain_common.h"
 #include "mongo/db/query/find_common.h"
 #include "mongo/db/query/fle/server_rewrite.h"
-#include "mongo/db/query/query_stats/agg_key.h"
-#include "mongo/db/query/query_stats/key.h"
-#include "mongo/db/query/query_stats/query_stats.h"
 #include "mongo/db/timeseries/timeseries_options.h"
 #include "mongo/db/views/resolved_view.h"
 #include "mongo/db/views/view.h"
@@ -99,7 +94,7 @@ namespace {
 // definition. It's okay that this is incorrect, we will repopulate the real namespace map on the
 // mongod. Note that this function must be called before forwarding an aggregation command on an
 // unsharded collection, in order to verify that the involved namespaces are allowed to be sharded.
-auto resolveInvolvedNamespaces(const stdx::unordered_set<NamespaceString>& involvedNamespaces) {
+auto resolveInvolvedNamespaces(stdx::unordered_set<NamespaceString> involvedNamespaces) {
     StringMap<ExpressionContext::ResolvedNamespace> resolvedNamespaces;
     for (auto&& nss : involvedNamespaces) {
         resolvedNamespaces.try_emplace(nss.coll(), nss, std::vector<BSONObj>{});
@@ -262,68 +257,6 @@ std::vector<BSONObj> rebuildPipelineWithTimeSeriesGranularity(const std::vector<
     return newPipeline;
 }
 
-/**
- * Builds an expCtx with which to parse the request's pipeline, then parses the pipeline and
- * registers the pre-optimized pipeline with query stats collection.
- */
-std::unique_ptr<Pipeline, PipelineDeleter> parsePipelineAndRegisterQueryStats(
-    OperationContext* opCtx,
-    const stdx::unordered_set<NamespaceString>& involvedNamespaces,
-    const NamespaceString& executionNss,
-    AggregateCommandRequest& request,
-    const boost::optional<ChunkManager>& cm,
-    const LiteParsedPipeline& liteParsedPipeline,
-    bool hasChangeStream,
-    bool shouldDoFLERewrite) {
-    // Populate the collection UUID and the appropriate collation to use.
-    auto [collationObj, uuid] = [&]() -> std::pair<BSONObj, boost::optional<UUID>> {
-        // If this is a change stream, take the user-defined collation if one exists, or an
-        // empty BSONObj otherwise. Change streams never inherit the collection's default
-        // collation, and since collectionless aggregations generally run on the 'admin'
-        // database, the standard logic would attempt to resolve its non-existent UUID and
-        // collation by sending a specious 'listCollections' command to the config servers.
-        if (hasChangeStream) {
-            return {request.getCollation().value_or(BSONObj()), boost::none};
-        }
-
-        return cluster_aggregation_planner::getCollationAndUUID(
-            opCtx, cm, executionNss, request.getCollation().value_or(BSONObj()));
-    }();
-
-    // Build an ExpressionContext for the pipeline. This instantiates an appropriate collator,
-    // resolves all involved namespaces, and creates a shared MongoProcessInterface for use by the
-    // pipeline's stages.
-    boost::intrusive_ptr<ExpressionContext> expCtx =
-        makeExpressionContext(opCtx,
-                              request,
-                              collationObj,
-                              uuid,
-                              resolveInvolvedNamespaces(involvedNamespaces),
-                              hasChangeStream);
-
-    // A pipeline with $changeStreamSplitLargeEvent requires the use of resume token format v2,
-    // since the 'fragmentNum' field only exists in this version and later.
-    if (hasChangeStream && liteParsedPipeline.endsWithChangeStreamSplitLargeEvent()) {
-        expCtx->changeStreamTokenVersion = 2;
-    }
-
-    // Parse and optimize the full pipeline.
-    auto pipeline = Pipeline::parse(request.getPipeline(), expCtx);
-
-    // Skip query stats recording for queryable encryption queries.
-    if (!shouldDoFLERewrite) {
-        query_stats::registerRequest(
-            opCtx,
-            executionNss,
-            [&]() {
-                return std::make_unique<query_stats::AggKey>(
-                    request, *pipeline, expCtx, involvedNamespaces, executionNss);
-            },
-            hasChangeStream);
-    }
-    return pipeline;
-}
-
 }  // namespace
 
 Status ClusterAggregate::runAggregate(OperationContext* opCtx,
@@ -376,7 +309,6 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
     auto hasChangeStream = liteParsedPipeline.hasChangeStream();
     auto involvedNamespaces = liteParsedPipeline.getInvolvedNamespaces();
     auto shouldDoFLERewrite = ::mongo::shouldDoFLERewrite(request);
-    auto startsWithDocuments = liteParsedPipeline.startsWithDocuments();
 
     // If the routing table is not already taken by the higher level, fill it now.
     if (!cm) {
@@ -391,14 +323,6 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
             sharded_agg_helpers::getExecutionNsRoutingInfo(opCtx, namespaces.executionNss);
 
         if (!executionNsRoutingInfoStatus.isOK()) {
-            uassert(CollectionUUIDMismatchInfo(request.getDbName().toString(),
-                                               *request.getCollectionUUID(),
-                                               request.getNamespace().coll().toString(),
-                                               boost::none),
-                    "Database does not exist",
-                    executionNsRoutingInfoStatus != ErrorCodes::NamespaceNotFound ||
-                        !request.getCollectionUUID());
-
             if (liteParsedPipeline.startsWithCollStats()) {
                 uassertStatusOKWithContext(executionNsRoutingInfoStatus,
                                            "Unable to retrieve information for $collStats stage");
@@ -407,7 +331,7 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
 
         if (executionNsRoutingInfoStatus.isOK()) {
             cm = std::move(executionNsRoutingInfoStatus.getValue());
-        } else if (!((hasChangeStream || startsWithDocuments) &&
+        } else if (!(hasChangeStream &&
                      executionNsRoutingInfoStatus == ErrorCodes::NamespaceNotFound)) {
             appendEmptyResultSetWithStatus(
                 opCtx, namespaces.requestedNss, executionNsRoutingInfoStatus.getStatus(), result);
@@ -417,15 +341,33 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
 
     boost::intrusive_ptr<ExpressionContext> expCtx;
     const auto pipelineBuilder = [&]() {
-        auto pipeline = parsePipelineAndRegisterQueryStats(opCtx,
-                                                           involvedNamespaces,
-                                                           namespaces.executionNss,
-                                                           request,
-                                                           cm,
-                                                           liteParsedPipeline,
-                                                           hasChangeStream,
-                                                           shouldDoFLERewrite);
-        expCtx = pipeline->getContext();
+        // Populate the collection UUID and the appropriate collation to use.
+        auto [collationObj, uuid] = [&]() -> std::pair<BSONObj, boost::optional<UUID>> {
+            // If this is a change stream, take the user-defined collation if one exists, or an
+            // empty BSONObj otherwise. Change streams never inherit the collection's default
+            // collation, and since collectionless aggregations generally run on the 'admin'
+            // database, the standard logic would attempt to resolve its non-existent UUID and
+            // collation by sending a specious 'listCollections' command to the config servers.
+            if (hasChangeStream) {
+                return {request.getCollation().value_or(BSONObj()), boost::none};
+            }
+
+            return cluster_aggregation_planner::getCollationAndUUID(
+                opCtx, cm, namespaces.executionNss, request.getCollation().value_or(BSONObj()));
+        }();
+
+        // Build an ExpressionContext for the pipeline. This instantiates an appropriate collator,
+        // resolves all involved namespaces, and creates a shared MongoProcessInterface for use by
+        // the pipeline's stages.
+        expCtx = makeExpressionContext(opCtx,
+                                       request,
+                                       collationObj,
+                                       uuid,
+                                       resolveInvolvedNamespaces(involvedNamespaces),
+                                       hasChangeStream);
+
+        // Parse and optimize the full pipeline.
+        auto pipeline = Pipeline::parse(request.getPipeline(), expCtx);
 
         // If the aggregate command supports encrypted collections, do rewrites of the pipeline to
         // support querying against encrypted fields.
@@ -439,11 +381,6 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
         }
 
         pipeline->optimizePipeline();
-
-        // Validate the pipeline post-optimization.
-        const bool alreadyOptimized = true;
-        pipeline->validateCommon(alreadyOptimized);
-
         return pipeline;
     };
 
@@ -458,7 +395,6 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
         cm,
         involvedNamespaces,
         hasChangeStream,
-        startsWithDocuments,
         allowedToPassthrough,
         request.getPassthroughToShard().has_value());
 
@@ -471,48 +407,15 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
                 cluster_aggregation_planner::AggregationTargeter::TargetingPolicy::kMongosRequired);
 
     if (!expCtx) {
-        // When the AggregationTargeter chooses a "passthrough" or "specific shard only" policy, it
-        // does not call the 'pipelineBuilder' function, so we've yet to construct an expression
-        // context or register query stats. Because this is a passthrough, we only need a bare
-        // minimum expression context on mongos.
+        // When the AggregationTargeter chooses a "passthrough" policy, it does not call the
+        // 'pipelineBuilder' function, so we never get an expression context. Because this is a
+        // passthrough, we only need a bare minimum expression context anyway.
         invariant(targeter.policy ==
                       cluster_aggregation_planner::AggregationTargeter::kPassthrough ||
                   targeter.policy ==
                       cluster_aggregation_planner::AggregationTargeter::kSpecificShardOnly);
-
         expCtx = make_intrusive<ExpressionContext>(
             opCtx, nullptr, namespaces.executionNss, boost::none, request.getLet());
-        expCtx->addResolvedNamespaces(involvedNamespaces);
-
-
-        // We might need 'inMongos' temporarily set to true for query stats parsing, but we don't
-        // want to modify the value of 'expCtx' for future code execution so we will set it back to
-        // its original value.
-        ON_BLOCK_EXIT([&expCtx, originalInMongosVal = expCtx->inMongos]() {
-            expCtx->inMongos = originalInMongosVal;
-        });
-
-        // In order to parse a change stream request for query stats, 'inMongos' needs
-        // to be set to true.
-        if (hasChangeStream) {
-            expCtx->inMongos = true;
-        }
-
-        // Skip query stats recording for queryable encryption queries.
-        if (!shouldDoFLERewrite) {
-            // We want to hold off parsing the pipeline until it's clear we must. Because of that,
-            // we wait to parse the pipeline until this callback is invoked within
-            // query_stats::registerRequest.
-            query_stats::registerRequest(
-                opCtx,
-                namespaces.executionNss,
-                [&]() {
-                    auto pipeline = Pipeline::parse(request.getPipeline(), expCtx);
-                    return std::make_unique<query_stats::AggKey>(
-                        request, *pipeline, expCtx, involvedNamespaces, namespaces.executionNss);
-                },
-                hasChangeStream);
-        }
     }
 
     if (request.getExplain()) {
@@ -540,11 +443,10 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
                 // If this is an explain write the explain output and return.
                 auto expCtx = targeter.pipeline->getContext();
                 if (expCtx->explain) {
-                    auto opts = SerializationOptions{};
-                    opts.verbosity = boost::make_optional(ExplainOptions::Verbosity::kQueryPlanner);
                     *result << "splitPipeline" << BSONNULL << "mongos"
                             << Document{{"host", getHostNameCachedAndPort()},
-                                        {"stages", targeter.pipeline->writeExplainOps(opts)}};
+                                        {"stages",
+                                         targeter.pipeline->writeExplainOps(*expCtx->explain)}};
                     return Status::OK();
                 }
 
@@ -567,8 +469,7 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
                     namespaces,
                     privileges,
                     result,
-                    hasChangeStream,
-                    startsWithDocuments);
+                    hasChangeStream);
             }
             case cluster_aggregation_planner::AggregationTargeter::TargetingPolicy::
                 kSpecificShardOnly: {
@@ -613,12 +514,11 @@ Status ClusterAggregate::runAggregate(OperationContext* opCtx,
         updateHostsTargetedMetrics(opCtx, namespaces.executionNss, cm, involvedNamespaces);
         // Report usage statistics for each stage in the pipeline.
         liteParsedPipeline.tickGlobalStageCounters();
+
         // Add 'command' object to explain output.
         if (expCtx->explain) {
             explain_common::appendIfRoom(
                 aggregation_request_helper::serializeToCommandObj(request), "command", result);
-            collectQueryStatsMongos(opCtx,
-                                    std::move(CurOp::get(opCtx)->debug().queryStatsInfo.key));
         }
     }
     return status;
diff --git a/src/mongo/s/query/cluster_aggregation_planner.cpp b/src/mongo/s/query/cluster_aggregation_planner.cpp
index 70adf70404a..3f970f2f8c1 100644
--- a/src/mongo/s/query/cluster_aggregation_planner.cpp
+++ b/src/mongo/s/query/cluster_aggregation_planner.cpp
@@ -65,7 +65,6 @@ namespace cluster_aggregation_planner {
 
 MONGO_FAIL_POINT_DEFINE(shardedAggregateFailToDispatchExchangeConsumerPipeline);
 MONGO_FAIL_POINT_DEFINE(shardedAggregateFailToEstablishMergingShardCursor);
-MONGO_FAIL_POINT_DEFINE(shardedAggregateHangBeforeDispatchMergingPipeline);
 
 using sharded_agg_helpers::DispatchShardPipelineResults;
 using sharded_agg_helpers::SplitPipeline;
@@ -172,13 +171,9 @@ Status dispatchMergingPipeline(const boost::intrusive_ptr<ExpressionContext>& ex
                                const PrivilegeVector& privileges,
                                bool hasChangeStream) {
     // We should never be in a situation where we call this function on a non-merge pipeline.
-    tassert(6525900,
-            "tried to dispatch merge pipeline but the pipeline was not split",
-            shardDispatchResults.splitPipeline);
+    invariant(shardDispatchResults.splitPipeline);
     auto* mergePipeline = shardDispatchResults.splitPipeline->mergePipeline.get();
-    tassert(6525901,
-            "tried to dispatch merge pipeline but there was no merge portion of the split pipeline",
-            mergePipeline);
+    invariant(mergePipeline);
     auto* opCtx = expCtx->opCtx;
 
     std::vector<ShardId> targetedShards;
@@ -237,13 +232,9 @@ Status dispatchMergingPipeline(const boost::intrusive_ptr<ExpressionContext>& ex
                             privileges,
                             expCtx->tailableMode));
 
-    // If the mergingShard returned an error and did not accept ownership it is our responsibility
-    // to kill the cursors.
-    uassertStatusOK(getStatusFromCommandResult(mergeResponse.swResponse.getValue().data));
-
-    // If we didn't get an error from the merging shard, ownership for the shard cursors has been
-    // transferred to the merging shard. Dismiss the ownership in the current merging pipeline such
-    // that when it goes out of scope it does not attempt to kill the cursors.
+    // Ownership for the shard cursors has been transferred to the merging shard. Dismiss the
+    // ownership in the current merging pipeline such that when it goes out of scope it does not
+    // attempt to kill the cursors.
     auto mergeCursors = static_cast<DocumentSourceMergeCursors*>(mergePipeline->peekFront());
     mergeCursors->dismissCursorOwnership();
 
@@ -345,27 +336,12 @@ BSONObj establishMergingMongosCursor(OperationContext* opCtx,
         responseBuilder.setPostBatchResumeToken(ccc->getPostBatchResumeToken());
     }
 
-    bool exhausted = cursorState != ClusterCursorManager::CursorState::NotExhausted;
-    int nShards = ccc->getNumRemotes();
-
-    auto&& opDebug = CurOp::get(opCtx)->debug();
-    // Fill out the aggregation metrics in CurOp, and record queryStats metrics, before detaching
-    // the cursor from its opCtx.
-    opDebug.nShards = std::max(opDebug.nShards, nShards);
-    opDebug.cursorExhausted = exhausted;
-    opDebug.additiveMetrics.nBatches = 1;
-    CurOp::get(opCtx)->setEndOfOpMetrics(responseBuilder.numDocs());
-    if (exhausted) {
-        collectQueryStatsMongos(opCtx, ccc->takeKey());
-    } else {
-        collectQueryStatsMongos(opCtx, ccc);
-    }
-
     ccc->detachFromOperationContext();
 
+    int nShards = ccc->getNumRemotes();
     CursorId clusterCursorId = 0;
 
-    if (!exhausted) {
+    if (cursorState == ClusterCursorManager::CursorState::NotExhausted) {
         auto authUsers = AuthorizationSession::get(opCtx->getClient())->getAuthenticatedUserNames();
         clusterCursorId = uassertStatusOK(Grid::get(opCtx)->getCursorManager()->registerCursor(
             opCtx,
@@ -374,9 +350,16 @@ BSONObj establishMergingMongosCursor(OperationContext* opCtx,
             ClusterCursorManager::CursorType::MultiTarget,
             ClusterCursorManager::CursorLifetime::Mortal,
             authUsers));
-        opDebug.cursorid = clusterCursorId;
     }
 
+    // Fill out the aggregation metrics in CurOp.
+    if (clusterCursorId > 0) {
+        CurOp::get(opCtx)->debug().cursorid = clusterCursorId;
+    }
+    CurOp::get(opCtx)->debug().nShards = std::max(CurOp::get(opCtx)->debug().nShards, nShards);
+    CurOp::get(opCtx)->debug().cursorExhausted = (clusterCursorId == 0);
+    CurOp::get(opCtx)->debug().nreturned = responseBuilder.numDocs();
+
     responseBuilder.done(clusterCursorId, requestedNss.ns());
 
     auto bodyBuilder = replyBuilder.getBodyBuilder();
@@ -391,9 +374,6 @@ DispatchShardPipelineResults dispatchExchangeConsumerPipeline(
     const NamespaceString& executionNss,
     Document serializedCommand,
     DispatchShardPipelineResults* shardDispatchResults) {
-    tassert(7163600,
-            "dispatchExchangeConsumerPipeline() must not be called for explain operation",
-            !expCtx->explain);
     auto opCtx = expCtx->opCtx;
 
     if (MONGO_unlikely(shardedAggregateFailToDispatchExchangeConsumerPipeline.shouldFail())) {
@@ -430,8 +410,7 @@ DispatchShardPipelineResults dispatchExchangeConsumerPipeline(
                                                                 serializedCommand,
                                                                 consumerPipelines.back(),
                                                                 boost::none, /* exchangeSpec */
-                                                                false /* needsMerge */,
-                                                                boost::none /* explain */);
+                                                                false /* needsMerge */);
 
         requests.emplace_back(shardDispatchResults->exchangeSpec->consumerShards[idx],
                               consumerCmdObj);
@@ -456,11 +435,8 @@ DispatchShardPipelineResults dispatchExchangeConsumerPipeline(
 
     SplitPipeline splitPipeline{nullptr, std::move(mergePipeline), boost::none};
 
-    // Relinquish ownership of the consumer pipelines' cursors. These cursors are now set up to be
-    // merged by a set of $mergeCursors pipelines that we just dispatched to the shards above. Now
-    // that we've established those pipelines on the shards, we are no longer responsible for
-    // ensuring they are cleaned up. If there was a problem establishing the cursors then
-    // establishCursors() would have thrown and mongos would kill all the consumer cursors itself.
+    // Relinquish ownership of the local consumer pipelines' cursors as each shard is now
+    // responsible for its own producer cursors.
     for (const auto& pipeline : consumerPipelines) {
         const auto& mergeCursors =
             static_cast<DocumentSourceMergeCursors*>(pipeline.shardsPipeline->peekFront());
@@ -587,7 +563,6 @@ AggregationTargeter AggregationTargeter::make(
     boost::optional<ChunkManager> cm,
     stdx::unordered_set<NamespaceString> involvedNamespaces,
     bool hasChangeStream,
-    bool startsWithDocuments,
     bool allowedToPassthrough,
     bool perShardCursor) {
     if (perShardCursor) {
@@ -607,13 +582,11 @@ AggregationTargeter AggregationTargeter::make(
     }();
 
     // Determine whether this aggregation must be dispatched to all shards in the cluster.
-    const bool mustRunOnAllShards = sharded_agg_helpers::checkIfMustRunOnAllShards(
-        executionNss, hasChangeStream, startsWithDocuments);
+    const bool mustRunOnAll =
+        sharded_agg_helpers::mustRunOnAllShards(executionNss, hasChangeStream);
 
-    // If we don't have a routing table, then this is either a $changeStream which must run on all
-    // shards or a $documents stage which must not.
-    invariant(cm || (mustRunOnAllShards && hasChangeStream) ||
-              (startsWithDocuments && !mustRunOnAllShards));
+    // If we don't have a routing table, then this is a $changeStream which must run on all shards.
+    invariant(cm || (mustRunOnAll && hasChangeStream));
 
     // A pipeline is allowed to passthrough to the primary shard iff the following conditions are
     // met:
@@ -625,7 +598,7 @@ AggregationTargeter AggregationTargeter::make(
     //    $currentOp.
     // 4. Doesn't need transformation via DocumentSource::serialize(). For example, list sessions
     //    needs to include information about users that can only be deduced on mongos.
-    if (cm && !cm->isSharded() && !mustRunOnAllShards && allowedToPassthrough &&
+    if (cm && !cm->isSharded() && !mustRunOnAll && allowedToPassthrough &&
         !involvesShardedCollections) {
         return AggregationTargeter{TargetingPolicy::kPassthrough, nullptr, cm};
     } else {
@@ -690,16 +663,11 @@ Status dispatchPipelineAndMerge(OperationContext* opCtx,
                                 const ClusterAggregate::Namespaces& namespaces,
                                 const PrivilegeVector& privileges,
                                 BSONObjBuilder* result,
-                                bool hasChangeStream,
-                                bool startsWithDocuments) {
+                                bool hasChangeStream) {
     auto expCtx = targeter.pipeline->getContext();
     // If not, split the pipeline as necessary and dispatch to the relevant shards.
-    auto shardDispatchResults =
-        sharded_agg_helpers::dispatchShardPipeline(serializedCommand,
-                                                   hasChangeStream,
-                                                   startsWithDocuments,
-                                                   std::move(targeter.pipeline),
-                                                   expCtx->explain);
+    auto shardDispatchResults = sharded_agg_helpers::dispatchShardPipeline(
+        serializedCommand, hasChangeStream, std::move(targeter.pipeline));
 
     // If the operation is an explain, then we verify that it succeeded on all targeted
     // shards, write the results to the output builder, and return immediately.
@@ -733,8 +701,6 @@ Status dispatchPipelineAndMerge(OperationContext* opCtx,
             expCtx, namespaces.executionNss, serializedCommand, &shardDispatchResults);
     }
 
-    shardedAggregateHangBeforeDispatchMergingPipeline.pauseWhileSet();
-
     // If we reach here, we have a merge pipeline to dispatch.
     return dispatchMergingPipeline(expCtx,
                                    namespaces,
@@ -867,7 +833,6 @@ Status runPipelineOnSpecificShardOnly(const boost::intrusive_ptr<ExpressionConte
     if (explain) {
         // If this was an explain, then we get back an explain result object rather than a cursor.
         result = response.swResponse.getValue().data;
-        collectQueryStatsMongos(opCtx, std::move(CurOp::get(opCtx)->debug().queryStatsInfo.key));
     } else {
         result = uassertStatusOK(storePossibleCursor(
             opCtx,
diff --git a/src/mongo/s/query/cluster_aggregation_planner.h b/src/mongo/s/query/cluster_aggregation_planner.h
index 78c919192db..046d8eab6ca 100644
--- a/src/mongo/s/query/cluster_aggregation_planner.h
+++ b/src/mongo/s/query/cluster_aggregation_planner.h
@@ -82,7 +82,6 @@ struct AggregationTargeter {
         boost::optional<ChunkManager> cm,
         stdx::unordered_set<NamespaceString> involvedNamespaces,
         bool hasChangeStream,
-        bool startsWithDocuments,
         bool allowedToPassthrough,
         bool perShardCursor);
 
@@ -126,8 +125,7 @@ Status dispatchPipelineAndMerge(OperationContext* opCtx,
                                 const ClusterAggregate::Namespaces& namespaces,
                                 const PrivilegeVector& privileges,
                                 BSONObjBuilder* result,
-                                bool hasChangeStream,
-                                bool startsWithDocuments);
+                                bool hasChangeStream);
 
 /**
  * Similar to runPipelineOnPrimaryShard but allows $changeStreams. Intended for use by per shard
diff --git a/src/mongo/s/query/cluster_client_cursor.h b/src/mongo/s/query/cluster_client_cursor.h
index 23a3367416d..8ff611eb308 100644
--- a/src/mongo/s/query/cluster_client_cursor.h
+++ b/src/mongo/s/query/cluster_client_cursor.h
@@ -211,30 +211,15 @@ public:
      */
     virtual boost::optional<uint32_t> getQueryHash() const = 0;
 
-    virtual boost::optional<std::size_t> getQueryStatsKeyHash() const = 0;
-
-    virtual bool getQueryStatsWillNeverExhaust() const = 0;
-
     /**
      * Returns the number of batches returned by this cursor.
      */
-    std::uint64_t getNBatches() const {
-        return _metrics.nBatches.value_or(0);
-    }
+    virtual std::uint64_t getNBatches() const = 0;
 
     /**
      * Increment the number of batches returned so far by one.
      */
-    void incNBatches() {
-        _metrics.incrementNBatches();
-    }
-
-    void incrementCursorMetrics(OpDebug::AdditiveMetrics newMetrics) {
-        _metrics.add(newMetrics);
-        if (!_firstResponseExecutionTime) {
-            _firstResponseExecutionTime = _metrics.executionTime;
-        }
-    }
+    virtual void incNBatches() = 0;
 
     //
     // maxTimeMS support.
@@ -260,20 +245,6 @@ public:
         _leftoverMaxTimeMicros = leftoverMaxTimeMicros;
     }
 
-    /**
-     * Returns and releases ownership of the Key associated with the request this
-     * cursor is handling.
-     */
-    virtual std::unique_ptr<query_stats::Key> takeKey() = 0;
-
-protected:
-    // Metrics that are accumulated over the lifetime of the cursor, incremented with each getMore.
-    // Useful for diagnostics like queryStats.
-    OpDebug::AdditiveMetrics _metrics;
-
-    // The execution time collected from the initial operation prior to any getMore requests.
-    boost::optional<Microseconds> _firstResponseExecutionTime;
-
 private:
     // Unused maxTime budget for this cursor.
     Microseconds _leftoverMaxTimeMicros = Microseconds::max();
diff --git a/src/mongo/s/query/cluster_client_cursor_impl.cpp b/src/mongo/s/query/cluster_client_cursor_impl.cpp
index 6b094a604f4..73be5a7512a 100644
--- a/src/mongo/s/query/cluster_client_cursor_impl.cpp
+++ b/src/mongo/s/query/cluster_client_cursor_impl.cpp
@@ -27,8 +27,6 @@
  *    it in the license file.
  */
 
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery
-
 #include "mongo/platform/basic.h"
 
 #include "mongo/s/query/cluster_client_cursor_impl.h"
@@ -36,8 +34,6 @@
 #include <memory>
 
 #include "mongo/db/curop.h"
-#include "mongo/db/query/query_stats/query_stats.h"
-#include "mongo/logv2/log.h"
 #include "mongo/s/query/router_stage_limit.h"
 #include "mongo/s/query/router_stage_merge.h"
 #include "mongo/s/query/router_stage_remove_metadata_fields.h"
@@ -79,10 +75,7 @@ ClusterClientCursorImpl::ClusterClientCursorImpl(OperationContext* opCtx,
       _opCtx(opCtx),
       _createdDate(opCtx->getServiceContext()->getPreciseClockSource()->now()),
       _lastUseDate(_createdDate),
-      _queryHash(CurOp::get(opCtx)->debug().queryHash),
-      _queryStatsKeyHash(CurOp::get(opCtx)->debug().queryStatsInfo.keyHash),
-      _queryStatsKey(std::move(CurOp::get(opCtx)->debug().queryStatsInfo.key)),
-      _queryStatsWillNeverExhaust(CurOp::get(opCtx)->debug().queryStatsInfo.willNeverExhaust) {
+      _queryHash(CurOp::get(opCtx)->debug().queryHash) {
     dassert(!_params.compareWholeSortKeyOnRouter ||
             SimpleBSONObjComparator::kInstance.evaluate(
                 _params.sortToApplyOnRouter == AsyncResultsMerger::kWholeSortKeySortPattern));
@@ -99,11 +92,7 @@ ClusterClientCursorImpl::ClusterClientCursorImpl(OperationContext* opCtx,
       _opCtx(opCtx),
       _createdDate(opCtx->getServiceContext()->getPreciseClockSource()->now()),
       _lastUseDate(_createdDate),
-      _queryHash(CurOp::get(opCtx)->debug().queryHash),
-      _queryStatsKeyHash(CurOp::get(opCtx)->debug().queryStatsInfo.keyHash),
-      _queryStatsKey(std::move(CurOp::get(opCtx)->debug().queryStatsInfo.key)),
-      _queryStatsWillNeverExhaust(
-          std::move(CurOp::get(opCtx)->debug().queryStatsInfo.willNeverExhaust)) {
+      _queryHash(CurOp::get(opCtx)->debug().queryHash) {
     dassert(!_params.compareWholeSortKeyOnRouter ||
             SimpleBSONObjComparator::kInstance.evaluate(
                 _params.sortToApplyOnRouter == AsyncResultsMerger::kWholeSortKeySortPattern));
@@ -111,7 +100,7 @@ ClusterClientCursorImpl::ClusterClientCursorImpl(OperationContext* opCtx,
 }
 
 ClusterClientCursorImpl::~ClusterClientCursorImpl() {
-    if (_metrics.nBatches && *_metrics.nBatches > 1)
+    if (_nBatchesReturned > 1)
         mongosCursorStatsMoreThanOneBatch.increment();
 }
 
@@ -139,25 +128,7 @@ StatusWith<ClusterQueryResult> ClusterClientCursorImpl::next() {
 }
 
 void ClusterClientCursorImpl::kill(OperationContext* opCtx) {
-    if (_hasBeenKilled) {
-        LOGV2_DEBUG(7372700,
-                    3,
-                    "Kill called on cluster client cursor after cursor has already been killed, so "
-                    "ignoring");
-        return;
-    }
-
-    query_stats::writeQueryStatsOnCursorDisposeOrKill(
-        opCtx,
-        _queryStatsKeyHash,
-        std::move(_queryStatsKey),
-        _queryStatsWillNeverExhaust,
-        _metrics.executionTime.value_or(Microseconds{0}).count(),
-        _firstResponseExecutionTime.value_or(Microseconds{0}).count(),
-        _metrics.nreturned.value_or(0));
-
     _root->kill(opCtx);
-    _hasBeenKilled = true;
 }
 
 void ClusterClientCursorImpl::reattachToOperationContext(OperationContext* opCtx) {
@@ -246,12 +217,12 @@ boost::optional<uint32_t> ClusterClientCursorImpl::getQueryHash() const {
     return _queryHash;
 }
 
-boost::optional<std::size_t> ClusterClientCursorImpl::getQueryStatsKeyHash() const {
-    return _queryStatsKeyHash;
+std::uint64_t ClusterClientCursorImpl::getNBatches() const {
+    return _nBatchesReturned;
 }
 
-bool ClusterClientCursorImpl::getQueryStatsWillNeverExhaust() const {
-    return _queryStatsWillNeverExhaust;
+void ClusterClientCursorImpl::incNBatches() {
+    ++_nBatchesReturned;
 }
 
 APIParameters ClusterClientCursorImpl::getAPIParameters() const {
@@ -294,7 +265,4 @@ std::unique_ptr<RouterExecStage> ClusterClientCursorImpl::buildMergerPlan(
     return root;
 }
 
-std::unique_ptr<query_stats::Key> ClusterClientCursorImpl::takeKey() {
-    return std::move(_queryStatsKey);
-}
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_client_cursor_impl.h b/src/mongo/s/query/cluster_client_cursor_impl.h
index 8064a45595b..2529254cfce 100644
--- a/src/mongo/s/query/cluster_client_cursor_impl.h
+++ b/src/mongo/s/query/cluster_client_cursor_impl.h
@@ -32,7 +32,6 @@
 #include <memory>
 #include <queue>
 
-#include "mongo/bson/bsonobj.h"
 #include "mongo/executor/task_executor.h"
 #include "mongo/s/query/cluster_client_cursor.h"
 #include "mongo/s/query/cluster_client_cursor_guard.h"
@@ -117,11 +116,9 @@ public:
 
     boost::optional<uint32_t> getQueryHash() const final;
 
-    boost::optional<std::size_t> getQueryStatsKeyHash() const final;
+    std::uint64_t getNBatches() const final;
 
-    bool getQueryStatsWillNeverExhaust() const final;
-
-    std::unique_ptr<query_stats::Key> takeKey() final;
+    void incNBatches() final;
 
 public:
     /**
@@ -178,19 +175,8 @@ private:
     // The hash of the query shape to be used for slow query logging;
     boost::optional<uint32_t> _queryHash;
 
-    // If boost::none, queryStats should not be collected for this cursor.
-    boost::optional<std::size_t> _queryStatsKeyHash;
-
-    // The Key used by query stats to generate the query stats store key.
-    std::unique_ptr<query_stats::Key> _queryStatsKey;
-
-    bool _queryStatsWillNeverExhaust = false;
-
-    // Tracks if kill() has been called on the cursor. Multiple calls to kill() are treated as a
-    // noop.
-    // TODO SERVER-74482 investigate where kill() is called multiple times and remove unnecessary
-    // calls
-    bool _hasBeenKilled = false;
+    // The number of batches returned by this cursor.
+    std::uint64_t _nBatchesReturned = 0;
 };
 
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_client_cursor_mock.cpp b/src/mongo/s/query/cluster_client_cursor_mock.cpp
index 103951694a0..567f3450499 100644
--- a/src/mongo/s/query/cluster_client_cursor_mock.cpp
+++ b/src/mongo/s/query/cluster_client_cursor_mock.cpp
@@ -89,6 +89,14 @@ long long ClusterClientCursorMock::getNumReturnedSoFar() const {
     return _numReturnedSoFar;
 }
 
+std::uint64_t ClusterClientCursorMock::getNBatches() const {
+    return _nBatchesReturned;
+}
+
+void ClusterClientCursorMock::incNBatches() {
+    ++_nBatchesReturned;
+}
+
 Date_t ClusterClientCursorMock::getCreatedDate() const {
     return _createdDate;
 }
@@ -105,14 +113,6 @@ boost::optional<uint32_t> ClusterClientCursorMock::getQueryHash() const {
     return boost::none;
 }
 
-boost::optional<std::size_t> ClusterClientCursorMock::getQueryStatsKeyHash() const {
-    return boost::none;
-}
-
-bool ClusterClientCursorMock::getQueryStatsWillNeverExhaust() const {
-    return false;
-}
-
 void ClusterClientCursorMock::kill(OperationContext* opCtx) {
     _killed = true;
     if (_killCallback) {
@@ -168,8 +168,4 @@ boost::optional<repl::ReadConcernArgs> ClusterClientCursorMock::getReadConcern()
     return boost::none;
 }
 
-std::unique_ptr<query_stats::Key> ClusterClientCursorMock::takeKey() {
-    return nullptr;
-}
-
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_client_cursor_mock.h b/src/mongo/s/query/cluster_client_cursor_mock.h
index 64ec06d750f..bc2991ecf89 100644
--- a/src/mongo/s/query/cluster_client_cursor_mock.h
+++ b/src/mongo/s/query/cluster_client_cursor_mock.h
@@ -33,7 +33,7 @@
 #include <functional>
 #include <queue>
 
-#include "mongo/db/query/query_stats/key.h"
+#include "mongo/db/logical_session_id.h"
 #include "mongo/s/query/cluster_client_cursor.h"
 
 namespace mongo {
@@ -106,9 +106,9 @@ public:
 
     boost::optional<uint32_t> getQueryHash() const final;
 
-    boost::optional<std::size_t> getQueryStatsKeyHash() const final;
+    std::uint64_t getNBatches() const final;
 
-    bool getQueryStatsWillNeverExhaust() const final;
+    void incNBatches() final;
 
     /**
      * Returns false unless the mock cursor has been fully iterated.
@@ -120,8 +120,6 @@ public:
      */
     void queueError(Status status);
 
-    std::unique_ptr<query_stats::Key> takeKey() final;
-
 private:
     bool _killed = false;
     std::queue<StatusWith<ClusterQueryResult>> _resultsQueue;
diff --git a/src/mongo/s/query/cluster_cursor_manager.cpp b/src/mongo/s/query/cluster_cursor_manager.cpp
index 4452e6a8811..1209d709e22 100644
--- a/src/mongo/s/query/cluster_cursor_manager.cpp
+++ b/src/mongo/s/query/cluster_cursor_manager.cpp
@@ -41,7 +41,6 @@
 #include "mongo/db/kill_sessions_common.h"
 #include "mongo/db/logical_session_cache.h"
 #include "mongo/db/query/query_knobs_gen.h"
-#include "mongo/db/query/query_stats/query_stats.h"
 #include "mongo/logv2/log.h"
 #include "mongo/util/clock_source.h"
 #include "mongo/util/str.h"
@@ -247,7 +246,6 @@ StatusWith<ClusterCursorManager::PinnedCursor> ClusterCursorManager::checkOutCur
     cursorGuard->reattachToOperationContext(opCtx);
 
     CurOp::get(opCtx)->debug().queryHash = cursorGuard->getQueryHash();
-    CurOp::get(opCtx)->debug().queryStatsInfo.keyHash = cursorGuard->getQueryStatsKeyHash();
 
     return PinnedCursor(this, std::move(cursorGuard), entry->getNamespace(), cursorId);
 }
@@ -576,60 +574,4 @@ StatusWith<ClusterClientCursorGuard> ClusterCursorManager::_detachCursor(WithLoc
 
     return std::move(cursor);
 }
-
-void collectQueryStatsMongos(OperationContext* opCtx, std::unique_ptr<query_stats::Key> key) {
-    // If we haven't registered a cursor to prepare for getMore requests, we record
-    // queryStats directly.
-    auto&& opDebug = CurOp::get(opCtx)->debug();
-    int64_t execTime = opDebug.additiveMetrics.executionTime.value_or(Microseconds{0}).count();
-    query_stats::writeQueryStats(opCtx,
-                                 opDebug.queryStatsInfo.keyHash,
-                                 std::move(key),
-                                 execTime,
-                                 execTime,
-                                 opDebug.additiveMetrics.nreturned.value_or(0));
-}
-
-void collectQueryStatsMongos(OperationContext* opCtx, ClusterClientCursorGuard& cursor) {
-    cursor->incrementCursorMetrics(CurOp::get(opCtx)->debug().additiveMetrics);
-
-    // For a change stream query that never ends, we want to collect query stats on the initial
-    // query and each getMore. Here we record the initial query.
-    // TODO SERVER-89058 Modify comment to include tailable cursors.
-    if (cursor->getQueryStatsWillNeverExhaust()) {
-        auto& opDebug = CurOp::get(opCtx)->debug();
-
-        int64_t execTime = opDebug.additiveMetrics.executionTime.value_or(Microseconds{0}).count();
-
-        query_stats::writeQueryStats(opCtx,
-                                     opDebug.queryStatsInfo.keyHash,
-                                     cursor->takeKey(),
-                                     execTime,
-                                     execTime,
-                                     opDebug.additiveMetrics.nreturned.value_or(0),
-                                     cursor->getQueryStatsWillNeverExhaust());
-    }
-}
-
-void collectQueryStatsMongos(OperationContext* opCtx, ClusterCursorManager::PinnedCursor& cursor) {
-    cursor->incrementCursorMetrics(CurOp::get(opCtx)->debug().additiveMetrics);
-
-    // For a change stream query that never ends, we want to update query stats for every getMore on
-    // the cursor.
-    // TODO SERVER-89058 Modify comment to include tailable cursors.
-    if (cursor->getQueryStatsWillNeverExhaust()) {
-        auto& opDebug = CurOp::get(opCtx)->debug();
-
-        int64_t execTime = opDebug.additiveMetrics.executionTime.value_or(Microseconds{0}).count();
-
-        query_stats::writeQueryStats(opCtx,
-                                     opDebug.queryStatsInfo.keyHash,
-                                     nullptr,
-                                     execTime,
-                                     execTime,
-                                     opDebug.additiveMetrics.nreturned.value_or(0),
-                                     cursor->getQueryStatsWillNeverExhaust());
-    }
-}
-
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_cursor_manager.h b/src/mongo/s/query/cluster_cursor_manager.h
index 73d07d91476..be10b0d60bd 100644
--- a/src/mongo/s/query/cluster_cursor_manager.h
+++ b/src/mongo/s/query/cluster_cursor_manager.h
@@ -599,19 +599,4 @@ private:
     size_t _cursorsTimedOut = 0;
 };
 
-/**
- * Record metrics for the current operation on opDebug and aggregates those metrics for queryStats
- * use. If a cursor is provided (via ClusterClientCursorGuard or
- * ClusterCursorManager::PinnedCursor), metrics are aggregated on the cursor; otherwise, metrics are
- * written directly to the queryStats store.
- * NOTE: Metrics are taken from opDebug.additiveMetrics, so CurOp::setEndOfOpMetrics must be called
- * *prior* to calling these.
- *
- * Currently, queryStats is only collected for find and aggregate requests (and their subsequent
- * getMore requests), so these should only be called from those request paths.
- */
-void collectQueryStatsMongos(OperationContext* opCtx, std::unique_ptr<query_stats::Key> key);
-void collectQueryStatsMongos(OperationContext* opCtx, ClusterClientCursorGuard& cursor);
-void collectQueryStatsMongos(OperationContext* opCtx, ClusterCursorManager::PinnedCursor& cursor);
-
 }  // namespace mongo
diff --git a/src/mongo/s/query/cluster_find.cpp b/src/mongo/s/query/cluster_find.cpp
index 01c78f9c3c5..bd186639684 100644
--- a/src/mongo/s/query/cluster_find.cpp
+++ b/src/mongo/s/query/cluster_find.cpp
@@ -33,7 +33,6 @@
 
 #include "mongo/s/query/cluster_find.h"
 
-#include "mongo/db/query/query_stats/query_stats.h"
 #include <fmt/format.h>
 
 #include <memory>
@@ -55,7 +54,6 @@
 #include "mongo/db/query/find_common.h"
 #include "mongo/db/query/getmore_command_gen.h"
 #include "mongo/db/query/query_planner_common.h"
-#include "mongo/db/query/query_stats/query_stats.h"
 #include "mongo/executor/task_executor_pool.h"
 #include "mongo/logv2/log.h"
 #include "mongo/platform/overflow_arithmetic.h"
@@ -63,7 +61,6 @@
 #include "mongo/s/client/num_hosts_targeted_metrics.h"
 #include "mongo/s/client/shard_registry.h"
 #include "mongo/s/cluster_commands_helpers.h"
-#include "mongo/s/collection_uuid_mismatch.h"
 #include "mongo/s/grid.h"
 #include "mongo/s/query/async_results_merger.h"
 #include "mongo/s/query/cluster_client_cursor_impl.h"
@@ -85,6 +82,11 @@ static const BSONObj kSortKeyMetaProjection = BSON("$meta"
                                                    << "sortKey");
 static const BSONObj kGeoNearDistanceMetaProjection = BSON("$meta"
                                                            << "geoNearDistance");
+// We must allow some amount of overhead per result document, since when we make a cursor response
+// the documents are elements of a BSONArray. The overhead is 1 byte/doc for the type + 1 byte/doc
+// for the field name's null terminator + 1 byte per digit in the array index. The index can be no
+// more than 8 decimal digits since the response is at most 16MB, and 16 * 1024 * 1024 < 1 * 10^8.
+static const int kPerDocumentOverheadBytesUpperBound = 10;
 
 const char kFindCmdName[] = "find";
 
@@ -301,9 +303,12 @@ CursorId runQueryWithoutRetrying(OperationContext* opCtx,
         if (ex.code() == ErrorCodes::CollectionUUIDMismatch &&
             !ex.extraInfo<CollectionUUIDMismatchInfo>()->actualCollection() &&
             !shardIds.count(cm.dbPrimary())) {
-            // We received CollectionUUIDMismatch but it does not contain the actual namespace, and
-            // we did not attempt to establish a cursor on the primary shard.
-            uassertStatusOK(populateCollectionUUIDMismatch(opCtx, ex.toStatus()));
+            // We received CollectionUUIDMismatchInfo but it does not contain the actual
+            // namespace, and we did not attempt to establish a cursor on the primary shard.
+            // Attempt to do so now in case the collection corresponding to the provided UUID is
+            // unsharded. This should throw CollectionUUIDMismatchInfo, StaleShardVersion, or
+            // StaleDbVersion.
+            establishCursorsOnShards({cm.dbPrimary()});
             MONGO_UNREACHABLE;
         }
 
@@ -336,7 +341,7 @@ CursorId runQueryWithoutRetrying(OperationContext* opCtx,
     FindCommon::waitInFindBeforeMakingBatch(opCtx, query);
 
     auto cursorState = ClusterCursorManager::CursorState::NotExhausted;
-    FindCommon::BSONArrayResponseSizeTracker responseSizeTracker;
+    size_t bytesBuffered = 0;
 
     // This loop will not result in actually calling getMore against shards, but just loading
     // results from the initial batches (that were obtained while establishing cursors) into
@@ -359,13 +364,14 @@ CursorId runQueryWithoutRetrying(OperationContext* opCtx,
 
         // If adding this object will cause us to exceed the message size limit, then we stash it
         // for later.
-        if (!responseSizeTracker.haveSpaceForNext(nextObj)) {
+        if (!FindCommon::haveSpaceForNext(nextObj, results->size(), bytesBuffered)) {
             ccc->queueResult(nextObj);
             break;
         }
 
-        // Add doc to the batch.
-        responseSizeTracker.add(nextObj);
+        // Add doc to the batch. Account for the space overhead associated with returning this doc
+        // inside a BSON array.
+        bytesBuffered += (nextObj.objsize() + kPerDocumentOverheadBytesUpperBound);
         results->push_back(std::move(nextObj));
     }
 
@@ -375,26 +381,23 @@ CursorId runQueryWithoutRetrying(OperationContext* opCtx,
         cursorState = ClusterCursorManager::CursorState::Exhausted;
     }
 
-    auto&& opDebug = CurOp::get(opCtx)->debug();
     // Fill out query exec properties.
-    opDebug.nShards = ccc->getNumRemotes();
-    opDebug.additiveMetrics.nBatches = 1;
+    CurOp::get(opCtx)->debug().nShards = ccc->getNumRemotes();
+    CurOp::get(opCtx)->debug().nreturned = results->size();
 
     // If the caller wants to know whether the cursor returned partial results, set it here.
     if (partialResultsReturned) {
         *partialResultsReturned = ccc->partialResultsReturned();
     }
 
-    CurOp::get(opCtx)->setEndOfOpMetrics(results->size());
     // If the cursor is exhausted, then there are no more results to return and we don't need to
     // allocate a cursor id.
     if (cursorState == ClusterCursorManager::CursorState::Exhausted) {
-        opDebug.cursorExhausted = true;
+        CurOp::get(opCtx)->debug().cursorExhausted = true;
 
         if (shardIds.size() > 0) {
             updateNumHostsTargetedMetrics(opCtx, cm, shardIds.size());
         }
-        collectQueryStatsMongos(opCtx, ccc->takeKey());
         return CursorId(0);
     }
 
@@ -405,13 +408,13 @@ CursorId runQueryWithoutRetrying(OperationContext* opCtx,
         ? ClusterCursorManager::CursorLifetime::Immortal
         : ClusterCursorManager::CursorLifetime::Mortal;
     auto authUsers = AuthorizationSession::get(opCtx->getClient())->getAuthenticatedUserNames();
-    collectQueryStatsMongos(opCtx, ccc);
+    ccc->incNBatches();
 
     auto cursorId = uassertStatusOK(cursorManager->registerCursor(
         opCtx, ccc.releaseCursor(), query.nss(), cursorType, cursorLifetime, authUsers));
 
     // Record the cursorID in CurOp.
-    opDebug.cursorid = cursorId;
+    CurOp::get(opCtx)->debug().cursorid = cursorId;
 
     if (shardIds.size() > 0) {
         updateNumHostsTargetedMetrics(opCtx, cm, shardIds.size());
@@ -471,19 +474,6 @@ Status setUpOperationContextStateForGetMore(OperationContext* opCtx,
     return Status::OK();
 }
 
-CursorId earlyExitWithNoResults(OperationContext* opCtx,
-                                const CanonicalQuery& query,
-                                const FindCommandRequest& findCommand) {
-    uassert(CollectionUUIDMismatchInfo(query.nss().db().toString(),
-                                       *findCommand.getCollectionUUID(),
-                                       query.nss().coll().toString(),
-                                       boost::none),
-            "Database does not exist",
-            !findCommand.getCollectionUUID());
-    collectQueryStatsMongos(opCtx, std::move(CurOp::get(opCtx)->debug().queryStatsInfo.key));
-
-    return CursorId(0);
-}
 }  // namespace
 
 const size_t ClusterFind::kMaxRetries = 10;
@@ -526,7 +516,7 @@ CursorId ClusterFind::runQuery(OperationContext* opCtx,
         if (swCM == ErrorCodes::NamespaceNotFound) {
             // If the database doesn't exist, we successfully return an empty result set without
             // creating a cursor.
-            return earlyExitWithNoResults(opCtx, query, findCommand);
+            return CursorId(0);
         }
 
         const auto cm = uassertStatusOK(std::move(swCM));
@@ -773,7 +763,7 @@ StatusWith<CursorResponse> ClusterFind::runGetMore(OperationContext* opCtx,
     }
 
     std::vector<BSONObj> batch;
-    FindCommon::BSONArrayResponseSizeTracker responseSizeTracker;
+    size_t bytesBuffered = 0;
     long long batchSize = cmd.getBatchSize().value_or(0);
     auto cursorState = ClusterCursorManager::CursorState::NotExhausted;
     BSONObj postBatchResumeToken;
@@ -826,7 +816,8 @@ StatusWith<CursorResponse> ClusterFind::runGetMore(OperationContext* opCtx,
             break;
         }
 
-        if (!responseSizeTracker.haveSpaceForNext(*next.getValue().getResult())) {
+        if (!FindCommon::haveSpaceForNext(
+                *next.getValue().getResult(), batch.size(), bytesBuffered)) {
             pinnedCursor.getValue()->queueResult(*next.getValue().getResult());
             stashedResult = true;
             break;
@@ -835,8 +826,10 @@ StatusWith<CursorResponse> ClusterFind::runGetMore(OperationContext* opCtx,
         // As soon as we get a result, this operation no longer waits.
         awaitDataState(opCtx).shouldWaitForInserts = false;
 
-        // Add doc to the batch.
-        responseSizeTracker.add(*next.getValue().getResult());
+        // Add doc to the batch. Account for the space overhead associated with returning this doc
+        // inside a BSON array.
+        bytesBuffered +=
+            (next.getValue().getResult()->objsize() + kPerDocumentOverheadBytesUpperBound);
         batch.push_back(std::move(*next.getValue().getResult()));
 
         // Update the postBatchResumeToken. For non-$changeStream aggregations, this will be empty.
@@ -853,20 +846,17 @@ StatusWith<CursorResponse> ClusterFind::runGetMore(OperationContext* opCtx,
         postBatchResumeToken = pinnedCursor.getValue()->getPostBatchResumeToken();
     }
 
-    auto&& opDebug = CurOp::get(opCtx)->debug();
-    // Set nReturned and whether the cursor has been exhausted.
-    opDebug.cursorExhausted = (idToReturn == 0);
-    opDebug.additiveMetrics.nBatches = 1;
-    CurOp::get(opCtx)->setEndOfOpMetrics(batch.size());
-
     const bool partialResultsReturned = pinnedCursor.getValue()->partialResultsReturned();
     pinnedCursor.getValue()->setLeftoverMaxTimeMicros(opCtx->getRemainingMaxTimeMicros());
-    collectQueryStatsMongos(opCtx, pinnedCursor.getValue());
-
+    pinnedCursor.getValue()->incNBatches();
     // Upon successful completion, transfer ownership of the cursor back to the cursor manager. If
     // the cursor has been exhausted, the cursor manager will clean it up for us.
     pinnedCursor.getValue().returnCursor(cursorState);
 
+    // Set nReturned and whether the cursor has been exhausted.
+    CurOp::get(opCtx)->debug().cursorExhausted = (idToReturn == 0);
+    CurOp::get(opCtx)->debug().nreturned = batch.size();
+
     if (MONGO_unlikely(waitBeforeUnpinningOrDeletingCursorAfterGetMoreBatch.shouldFail())) {
         CurOpFailpointHelpers::waitWhileFailPointEnabled(
             &waitBeforeUnpinningOrDeletingCursorAfterGetMoreBatch,
diff --git a/src/mongo/s/query/document_source_merge_cursors.cpp b/src/mongo/s/query/document_source_merge_cursors.cpp
index 34f6b1f11e6..c6f8f3fbaf6 100644
--- a/src/mongo/s/query/document_source_merge_cursors.cpp
+++ b/src/mongo/s/query/document_source_merge_cursors.cpp
@@ -52,6 +52,7 @@ DocumentSourceMergeCursors::DocumentSourceMergeCursors(
     : DocumentSource(kStageName, expCtx),
       _armParamsObj(std::move(ownedParamsSpec)),
       _armParams(std::move(armParams)) {
+    _armParams->setRecordRemoteOpWaitTime(true);
 
     // Populate the shard ids from the 'RemoteCursor'.
     recordRemoteCursorShardIds(_armParams->getRemotes());
@@ -82,6 +83,7 @@ bool DocumentSourceMergeCursors::remotesExhausted() const {
 void DocumentSourceMergeCursors::populateMerger() {
     invariant(!_blockingResultsMerger);
     invariant(_armParams);
+    invariant(_armParams->getRecordRemoteOpWaitTime());
 
     _blockingResultsMerger.emplace(
         pExpCtx->opCtx,
@@ -114,10 +116,11 @@ DocumentSource::GetNextResult DocumentSourceMergeCursors::doGetNext() {
     return Document::fromBsonWithMetaData(*next.getResult());
 }
 
-Value DocumentSourceMergeCursors::serialize(const SerializationOptions& opts) const {
+Value DocumentSourceMergeCursors::serialize(
+    boost::optional<ExplainOptions::Verbosity> explain) const {
     invariant(!_blockingResultsMerger);
     invariant(_armParams);
-    return Value(Document{{kStageName, _armParams->toBSON(opts)}});
+    return Value(Document{{kStageName, _armParams->toBSON()}});
 }
 
 boost::intrusive_ptr<DocumentSource> DocumentSourceMergeCursors::createFromBson(
diff --git a/src/mongo/s/query/document_source_merge_cursors.h b/src/mongo/s/query/document_source_merge_cursors.h
index 4eb75bd34bd..33050bf45ab 100644
--- a/src/mongo/s/query/document_source_merge_cursors.h
+++ b/src/mongo/s/query/document_source_merge_cursors.h
@@ -80,7 +80,7 @@ public:
     /**
      * Serializes this stage to be sent to perform the merging on a different host.
      */
-    Value serialize(const SerializationOptions& opts = SerializationOptions{}) const final override;
+    Value serialize(boost::optional<ExplainOptions::Verbosity> explain = boost::none) const final;
 
     StageConstraints constraints(Pipeline::SplitState pipeState) const final {
         StageConstraints constraints(StreamType::kStreaming,
diff --git a/src/mongo/s/query/establish_cursors.cpp b/src/mongo/s/query/establish_cursors.cpp
index 18196d76751..82ec1df2809 100644
--- a/src/mongo/s/query/establish_cursors.cpp
+++ b/src/mongo/s/query/establish_cursors.cpp
@@ -42,11 +42,8 @@
 #include "mongo/db/cursor_id.h"
 #include "mongo/db/query/cursor_response.h"
 #include "mongo/db/query/kill_cursors_gen.h"
-#include "mongo/db/query/query_knobs_gen.h"
-#include "mongo/executor/async_multicaster.h"
 #include "mongo/executor/remote_command_request.h"
 #include "mongo/executor/remote_command_response.h"
-#include "mongo/executor/task_executor.h"
 #include "mongo/logv2/log.h"
 #include "mongo/s/grid.h"
 #include "mongo/s/multi_statement_transaction_requests_sender.h"
@@ -105,13 +102,12 @@ public:
         return std::exchange(_remoteCursors, {});
     };
 
-    static void killOpOnShards(ServiceContext* srvCtx,
-                               std::shared_ptr<executor::TaskExecutor> executor,
-                               OperationKey opKey,
-                               std::set<HostAndPort> remotes) noexcept;
-
 private:
     void _handleFailure(const AsyncRequestsSender::Response& response, Status status) noexcept;
+    static void _killOpOnShards(ServiceContext* srvCtx,
+                                std::shared_ptr<executor::TaskExecutor> executor,
+                                OperationKey opKey,
+                                std::set<HostAndPort> remotes) noexcept;
 
     /**
      * Favors the status with 'CollectionUUIDMismatch' error to be saved in '_maybeFailure' to be
@@ -133,26 +129,22 @@ private:
     std::vector<HostAndPort> _remotesToClean;
 };
 
-// Attach our OperationKey to a request. This will allow us to kill any outstanding
-// requests in case we're interrupted or one of the remotes returns an error. Note that although
-// the opCtx may have an OperationKey set on it already, do not inherit it here because we may
-// target ourselves which implies the same node receiving multiple operations with the same
-// opKey.
-BSONObj appendOpKey(const OperationKey& opKey, const BSONObj& request) {
-    BSONObjBuilder newCmd(request);
-    opKey.appendToBuilder(&newCmd, "clientOperationKey");
-    return newCmd.obj();
-}
-
 void CursorEstablisher::sendRequests(const ReadPreferenceSetting& readPref,
                                      const std::vector<std::pair<ShardId, BSONObj>>& remotes,
                                      Shard::RetryPolicy retryPolicy) {
     // Construct the requests
     std::vector<AsyncRequestsSender::Request> requests;
 
+    // Attach our OperationKey to each remote request. This will allow us to kill any outstanding
+    // requests in case we're interrupted or one of the remotes returns an error. Note that although
+    // the opCtx may have an OperationKey set on it already, do not inherit it here because we may
+    // target ourselves which implies the same node receiving multiple operations with the same
+    // opKey.
     // TODO SERVER-47261 management of the opKey should move to the ARS.
     for (const auto& remote : remotes) {
-        requests.emplace_back(remote.first, appendOpKey(_opKey, remote.second));
+        BSONObjBuilder requestWithOpKey(remote.second);
+        _opKey.appendToBuilder(&requestWithOpKey, "clientOperationKey");
+        requests.emplace_back(remote.first, requestWithOpKey.obj());
     }
 
     LOGV2_DEBUG(4625502,
@@ -190,9 +182,11 @@ void CursorEstablisher::waitForResponse() noexcept {
 
             hadValidCursor = true;
 
-            _remoteCursors.emplace_back(RemoteCursor(response.shardId.toString(),
-                                                     *response.shardHostAndPort,
-                                                     std::move(cursor.getValue())));
+            RemoteCursor remoteCursor;
+            remoteCursor.setCursorResponse(std::move(cursor.getValue()));
+            remoteCursor.setShardId(response.shardId);
+            remoteCursor.setHostAndPort(*response.shardHostAndPort);
+            _remoteCursors.emplace_back(std::move(remoteCursor));
         }
 
         if (response.shardHostAndPort && !hadValidCursor) {
@@ -205,41 +199,16 @@ void CursorEstablisher::waitForResponse() noexcept {
     }
 }
 
-// Schedule killOperations against all cursors that were established. Make sure to
-// capture arguments by value since the cleanup work may get scheduled after
-// returning from this function.
-StatusWith<executor::TaskExecutor::CallbackHandle> scheduleCursorCleanup(
-    std::shared_ptr<executor::TaskExecutor> executor,
-    ServiceContext* svcCtx,
-    OperationKey opKey,
-    std::set<HostAndPort>&& remotesToClean) {
-    return executor->scheduleWork([svcCtx = svcCtx,
-                                   executor = executor,
-                                   opKey = opKey,
-                                   remotesToClean = std::move(remotesToClean)](
-                                      const executor::TaskExecutor::CallbackArgs& args) mutable {
-        if (!args.status.isOK()) {
-            LOGV2_WARNING(
-                7355702, "Failed to schedule remote cursor cleanup", "error"_attr = args.status);
-            return;
-        }
-        CursorEstablisher::killOpOnShards(
-            svcCtx, std::move(executor), std::move(opKey), std::move(remotesToClean));
-    });
-}
-
 void CursorEstablisher::checkForFailedRequests() {
     if (!_maybeFailure) {
         // If we saw no failures, there is nothing to do.
         return;
     }
 
-    if (!(_maybeFailure->code() == ErrorCodes::CommandOnShardedViewNotSupportedOnMongod)) {
-        LOGV2(4625501,
-              "Unable to establish remote cursors",
-              "error"_attr = *_maybeFailure,
-              "nRemotes"_attr = _remotesToClean.size());
-    }
+    LOGV2(4625501,
+          "Unable to establish remote cursors",
+          "error"_attr = *_maybeFailure,
+          "nRemotes"_attr = _remotesToClean.size());
 
     if (_remotesToClean.empty()) {
         // If we don't have any remotes to clean, throw early.
@@ -249,8 +218,21 @@ void CursorEstablisher::checkForFailedRequests() {
     // Filter out duplicate hosts.
     auto remotes = std::set<HostAndPort>(_remotesToClean.begin(), _remotesToClean.end());
 
-    uassertStatusOK(
-        scheduleCursorCleanup(_executor, _opCtx->getServiceContext(), _opKey, std::move(remotes)));
+    // Schedule killOperations against all cursors that were established. Make sure to
+    // capture arguments by value since the cleanup work may get scheduled after
+    // returning from this function.
+    uassertStatusOK(_executor->scheduleWork(
+        [svcCtx = _opCtx->getServiceContext(),
+         executor = _executor,
+         opKey = _opKey,
+         remotes = std::move(remotes)](const executor::TaskExecutor::CallbackArgs& args) mutable {
+            if (!args.status.isOK()) {
+                LOGV2_WARNING(
+                    48038, "Failed to schedule remote cursor cleanup", "error"_attr = args.status);
+                return;
+            }
+            _killOpOnShards(svcCtx, std::move(executor), std::move(opKey), std::move(remotes));
+        }));
 
     // Throw our failure.
     uassertStatusOK(*_maybeFailure);
@@ -312,10 +294,10 @@ void CursorEstablisher::_handleFailure(const AsyncRequestsSender::Response& resp
     _maybeFailure = std::move(status);
 }
 
-void CursorEstablisher::killOpOnShards(ServiceContext* srvCtx,
-                                       std::shared_ptr<executor::TaskExecutor> executor,
-                                       OperationKey opKey,
-                                       std::set<HostAndPort> remotes) noexcept try {
+void CursorEstablisher::_killOpOnShards(ServiceContext* srvCtx,
+                                        std::shared_ptr<executor::TaskExecutor> executor,
+                                        OperationKey opKey,
+                                        std::set<HostAndPort> remotes) noexcept try {
     ThreadClient tc("establishCursors cleanup", srvCtx);
     auto opCtx = tc->makeOperationContext();
 
@@ -345,16 +327,6 @@ void CursorEstablisher::killOpOnShards(ServiceContext* srvCtx,
 } catch (const AssertionException& ex) {
     LOGV2_DEBUG(4625503, 2, "Failed to cleanup remote operations", "error"_attr = ex.toStatus());
 }
-/**
- * Returns a copy of 'cmdObj' with the $readPreference mode set to secondaryPreferred.
- */
-BSONObj appendReadPreferenceNearest(BSONObj cmdObj) {
-    BSONObjBuilder cmdWithReadPrefBob(std::move(cmdObj));
-    cmdWithReadPrefBob.append("$readPreference",
-                              BSON("mode"
-                                   << "nearest"));
-    return cmdWithReadPrefBob.obj();
-}
 
 }  // namespace
 
@@ -386,101 +358,4 @@ void killRemoteCursor(OperationContext* opCtx,
     executor->scheduleRemoteCommand(request, [](auto const&) {}).getStatus().ignore();
 }
 
-std::pair<std::vector<HostAndPort>, StringMap<ShardId>> getHostInfos(
-    OperationContext* opCtx, const std::set<ShardId>& shardIds) {
-    std::vector<HostAndPort> servers;
-    StringMap<ShardId> hostToShardId;
-
-    // Get the host/port of every node in each shard.
-    auto registry = Grid::get(opCtx)->shardRegistry();
-    for (const auto& shardId : shardIds) {
-        auto shard = uassertStatusOK(registry->getShard(opCtx, shardId));
-        auto cs = shard->getConnString();
-        auto shardServers = cs.getServers();
-        for (auto& host : shardServers) {
-            hostToShardId.emplace(host.toString(), shardId);
-        }
-        servers.insert(servers.end(), shardServers.begin(), shardServers.end());
-    }
-    return {std::move(servers), hostToShardId};
-}
-
-std::vector<RemoteCursor> establishCursorsOnAllHosts(
-    OperationContext* opCtx,
-    std::shared_ptr<executor::TaskExecutor> executor,
-    const NamespaceString& nss,
-    const std::set<ShardId>& shardIds,
-    BSONObj cmdObj,
-    bool allowPartialResults,
-    Shard::RetryPolicy retryPolicy) {
-    auto [servers, hostToShardId] = getHostInfos(opCtx, shardIds);
-    OperationKey opKey = UUID::gen();
-
-    // Operation key will allow us to kill any outstanding requests in case we're interrupted.
-    // Secondaries will reject aggregation commands with a default read preference (primary). The
-    // actual semantics of read preference don't make as much sense when broadcasting to all
-    // shards, but we will set read preference to 'nearest' since it does not imply preference for
-    // primary or secondary.
-    BSONObj cmd = appendOpKey(opKey, appendReadPreferenceNearest(cmdObj));
-
-    executor::AsyncMulticaster::Options options;
-    options.maxConcurrency = internalQueryAggMulticastMaxConcurrency;
-    auto results = executor::AsyncMulticaster(executor, options)
-                       .multicast(servers,
-                                  nss.db().toString(),
-                                  cmd,
-                                  opCtx,
-                                  Milliseconds(internalQueryAggMulticastTimeoutMS));
-    std::vector<RemoteCursor> remoteCursors;
-    std::set<HostAndPort> remotesToClean;
-
-    boost::optional<Status> failure;
-
-    for (auto&& [hostAndPort, result] : results) {
-        if (result.isOK()) {
-            auto cursors = CursorResponse::parseFromBSONMany(result.data);
-            bool hadValidCursor = false;
-
-            auto it = hostToShardId.find(hostAndPort.toString());
-            tassert(7355701, "Host must have shard ID.", it != hostToShardId.end());
-            auto shardId = it->second;
-
-            for (auto& cursor : cursors) {
-                if (!cursor.isOK()) {
-                    failure = cursor.getStatus();
-                    continue;
-                }
-                hadValidCursor = true;
-
-                remoteCursors.emplace_back(
-                    RemoteCursor(shardId.toString(), hostAndPort, std::move(cursor.getValue())));
-            }
-
-            if (hadValidCursor) {
-                remotesToClean.insert(hostAndPort);
-            }
-        } else {
-            LOGV2_DEBUG(7355700,
-                        3,
-                        "Experienced a failure while establishing cursors",
-                        "error"_attr = result.status);
-            failure = result.status;
-        }
-    }
-    if (failure.has_value() && !allowPartialResults) {
-        LOGV2(7355705,
-              "Unable to establish remote cursors",
-              "error"_attr = *failure,
-              "nRemotes"_attr = remoteCursors.size());
-
-        if (!remotesToClean.empty()) {
-            uassertStatusOK(scheduleCursorCleanup(
-                executor, opCtx->getServiceContext(), opKey, std::move(remotesToClean)));
-        }
-
-        uassertStatusOK(failure.value());
-    }
-    return remoteCursors;
-}
-
 }  // namespace mongo
diff --git a/src/mongo/s/query/establish_cursors.h b/src/mongo/s/query/establish_cursors.h
index cd19af7eea9..3a904adcadd 100644
--- a/src/mongo/s/query/establish_cursors.h
+++ b/src/mongo/s/query/establish_cursors.h
@@ -73,26 +73,6 @@ std::vector<RemoteCursor> establishCursors(
     Shard::RetryPolicy retryPolicy = Shard::RetryPolicy::kIdempotent);
 
 /**
- * Establishes cursors on every host in the remote shards by issuing requests in parallel with the
- * AsyncMulticaster.
- *
- * If any of the cursors fail to be established, this function performs cleanup by sending
- * killCursors to any cursors that were established, then throws the error. If the namespace
- * represents a view, an exception containing a ResolvedView is thrown.
- *
- * On success, the ownership of the cursors is transferred to the caller. This means the caller is
- * now responsible for either exhausting the cursors or sending killCursors to them.
- */
-std::vector<RemoteCursor> establishCursorsOnAllHosts(
-    OperationContext* opCtx,
-    std::shared_ptr<executor::TaskExecutor> executor,
-    const NamespaceString& nss,
-    const std::set<ShardId>& shardIds,
-    BSONObj cmdObj,
-    bool allowPartialResults,
-    Shard::RetryPolicy retryPolicy = Shard::RetryPolicy::kIdempotent);
-
-/**
  * Schedules a remote killCursor command for 'cursor'.
  *
  * Note that this method is optimistic and does not check the return status for the killCursors
diff --git a/src/mongo/s/query/router_stage_remove_metadata_fields.cpp b/src/mongo/s/query/router_stage_remove_metadata_fields.cpp
index 7f3d89beef1..320c441ef46 100644
--- a/src/mongo/s/query/router_stage_remove_metadata_fields.cpp
+++ b/src/mongo/s/query/router_stage_remove_metadata_fields.cpp
@@ -53,14 +53,9 @@ StatusWith<ClusterQueryResult> RouterStageRemoveMetadataFields::next() {
     }
 
     BSONObjIterator iterator(*childResult.getValue().getResult());
-
     // Find the first field that we need to remove.
-    for (; iterator.more(); ++iterator) {
-        // To save some time, we ensure that the current field name starts with a $
-        // before checking if it's actually a metadata field in the map.
-        if ((*iterator).fieldName()[0] == '$' && _metaFields.contains((*iterator).fieldName())) {
-            break;
-        }
+    while (iterator.more() && (*iterator).fieldName()[0] != '$') {
+        ++iterator;
     }
 
     if (!iterator.more()) {
diff --git a/src/mongo/s/query/router_stage_remove_metadata_fields_test.cpp b/src/mongo/s/query/router_stage_remove_metadata_fields_test.cpp
index 9fa199a2ac9..a18aa0cbb31 100644
--- a/src/mongo/s/query/router_stage_remove_metadata_fields_test.cpp
+++ b/src/mongo/s/query/router_stage_remove_metadata_fields_test.cpp
@@ -194,60 +194,6 @@ TEST(RouterStageRemoveMetadataFieldsTest, ForwardsAwaitDataTimeout) {
     ASSERT_EQ(789, durationCount<Milliseconds>(awaitDataTimeout.getValue()));
 }
 
-// Grabs the next document from a stage and ensure it matches expectedDoc.
-// Assumes that remotes are exhausted after one document.
-void verifyNextDocument(RouterExecStage* stage, const BSONObj& expectedDoc) {
-    auto result = stage->next();
-    ASSERT_OK(result.getStatus());
-    ASSERT(result.getValue().getResult());
-    ASSERT_BSONOBJ_EQ(*result.getValue().getResult(), expectedDoc);
-    ASSERT_TRUE(stage->remotesExhausted());
-}
-
-TEST(RouterStageRemoveMetadataFieldsTest, AllowsNonMetaDataDollars) {
-    auto mockStage = std::make_unique<RouterStageMock>(opCtx);
-    mockStage->queueResult(BSON("$a" << 1 << "$sortKey" << 1 << "b" << 1));
-    mockStage->queueResult(BSON("a" << 2 << "$sortKey" << 1 << "$b" << 2));
-    mockStage->markRemotesExhausted();
-
-    auto sortKeyStage = std::make_unique<RouterStageRemoveMetadataFields>(
-        opCtx, std::move(mockStage), StringDataSet{"$sortKey"_sd});
-    ASSERT_TRUE(sortKeyStage->remotesExhausted());
-
-    verifyNextDocument(sortKeyStage.get(), BSON("$a" << 1 << "b" << 1));
-    verifyNextDocument(sortKeyStage.get(), BSON("a" << 2 << "$b" << 2));
-
-    auto endResult = sortKeyStage->next();
-    ASSERT_OK(endResult.getStatus());
-    ASSERT(endResult.getValue().isEOF());
-    ASSERT_TRUE(sortKeyStage->remotesExhausted());
-}
-
-// For every keyword, ensure it's removed if it's in the first, middle, or
-// last position, and that the remainder of the document is undisturbed.
-TEST(RouterStageRemoveMetadataFieldsTest, RemovesAllMetaDataDollars) {
-    for (auto& keyword : Document::allMetadataFieldNames) {
-        auto mockStage = std::make_unique<RouterStageMock>(opCtx);
-        mockStage->queueResult(BSON(keyword << 1 << "$a" << 1));
-        mockStage->queueResult(BSON("$a" << 1 << keyword << 1));
-        mockStage->queueResult(BSON("$a" << 1 << keyword << 1 << "$b" << 1));
-        mockStage->markRemotesExhausted();
-
-        auto sortKeyStage = std::make_unique<RouterStageRemoveMetadataFields>(
-            opCtx, std::move(mockStage), Document::allMetadataFieldNames);
-        ASSERT_TRUE(sortKeyStage->remotesExhausted());
-
-        verifyNextDocument(sortKeyStage.get(), BSON("$a" << 1));
-        verifyNextDocument(sortKeyStage.get(), BSON("$a" << 1));
-        verifyNextDocument(sortKeyStage.get(), BSON("$a" << 1 << "$b" << 1));
-
-        auto endResult = sortKeyStage->next();
-        ASSERT_OK(endResult.getStatus());
-        ASSERT(endResult.getValue().isEOF());
-        ASSERT_TRUE(sortKeyStage->remotesExhausted());
-    }
-}
-
 }  // namespace
 
 }  // namespace mongo
diff --git a/src/mongo/s/query/store_possible_cursor.cpp b/src/mongo/s/query/store_possible_cursor.cpp
index 723cafff2e4..c778daa9d84 100644
--- a/src/mongo/s/query/store_possible_cursor.cpp
+++ b/src/mongo/s/query/store_possible_cursor.cpp
@@ -88,17 +88,15 @@ StatusWith<BSONObj> storePossibleCursor(OperationContext* opCtx,
         return incomingCursorResponse.getStatus();
     }
 
-    auto&& opDebug = CurOp::get(opCtx)->debug();
-    opDebug.additiveMetrics.nBatches = 1;
+    CurOp::get(opCtx)->debug().nreturned = incomingCursorResponse.getValue().getBatch().size();
+
     // If nShards has already been set, then we are storing the forwarding $mergeCursors cursor from
     // a split aggregation pipeline, and the shards half of that pipeline may have targeted multiple
     // shards. In that case, leave the current value as-is.
-    opDebug.nShards = std::max(opDebug.nShards, 1);
-    CurOp::get(opCtx)->setEndOfOpMetrics(incomingCursorResponse.getValue().getBatch().size());
+    CurOp::get(opCtx)->debug().nShards = std::max(CurOp::get(opCtx)->debug().nShards, 1);
 
     if (incomingCursorResponse.getValue().getCursorId() == CursorId(0)) {
-        opDebug.cursorExhausted = true;
-        collectQueryStatsMongos(opCtx, std::move(opDebug.queryStatsInfo.key));
+        CurOp::get(opCtx)->debug().cursorExhausted = true;
         return cmdResult;
     }
 
@@ -130,7 +128,7 @@ StatusWith<BSONObj> storePossibleCursor(OperationContext* opCtx,
     }
 
     auto ccc = ClusterClientCursorImpl::make(opCtx, std::move(executor), std::move(params));
-    collectQueryStatsMongos(opCtx, ccc);
+    ccc->incNBatches();
     // We don't expect to use this cursor until a subsequent getMore, so detach from the current
     // OperationContext until then.
     ccc->detachFromOperationContext();
@@ -146,7 +144,7 @@ StatusWith<BSONObj> storePossibleCursor(OperationContext* opCtx,
         return clusterCursorId.getStatus();
     }
 
-    opDebug.cursorid = clusterCursorId.getValue();
+    CurOp::get(opCtx)->debug().cursorid = clusterCursorId.getValue();
 
     CursorResponse outgoingCursorResponse(
         requestedNss,
diff --git a/src/mongo/s/request_types/auto_split_vector.idl b/src/mongo/s/request_types/auto_split_vector.idl
index 3e55eb01d8e..abcbece2019 100644
--- a/src/mongo/s/request_types/auto_split_vector.idl
+++ b/src/mongo/s/request_types/auto_split_vector.idl
@@ -75,7 +75,3 @@ commands:
         maxChunkSizeBytes:
             type: safeInt64
             description: "Max chunk size of the collection expressed in bytes"
-        limit:
-            type: int
-            description: "Max number of split points to look for"
-            optional: true
diff --git a/src/mongo/s/request_types/balancer_collection_status.idl b/src/mongo/s/request_types/balancer_collection_status.idl
index a821222f933..53e86886562 100644
--- a/src/mongo/s/request_types/balancer_collection_status.idl
+++ b/src/mongo/s/request_types/balancer_collection_status.idl
@@ -40,7 +40,7 @@ structs:
         strict: false
         fields:
             chunkSize:
-                type: safeDouble
+                type: safeInt64
                 description: "Configured chunk size in MiB for this collection"
             balancerCompliant:
                 type: bool
diff --git a/src/mongo/s/request_types/commit_chunk_migration_request_type.h b/src/mongo/s/request_types/commit_chunk_migration_request_type.h
index 073ef9404f6..16d5f0ef8ce 100644
--- a/src/mongo/s/request_types/commit_chunk_migration_request_type.h
+++ b/src/mongo/s/request_types/commit_chunk_migration_request_type.h
@@ -81,11 +81,6 @@ public:
     const Timestamp& getCollectionTimestamp() {
         return _collectionTimestamp;
     }
-    /*
-     * NOTE: v7.0 is deprecating the _validAfter field of CommitChunkMigrationRequest
-     *       (see SERVER-74469 for details).
-     *       This method should not be used to develop new functionality.
-     */
     const boost::optional<Timestamp>& getValidAfter() {
         return _validAfter;
     }
diff --git a/src/mongo/s/request_types/get_stats_for_balancing.idl b/src/mongo/s/request_types/get_stats_for_balancing.idl
deleted file mode 100644
index 7ee96da4eaa..00000000000
--- a/src/mongo/s/request_types/get_stats_for_balancing.idl
+++ /dev/null
@@ -1,84 +0,0 @@
-# Copyright (C) 2022-present MongoDB, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the Server Side Public License, version 1,
-# as published by MongoDB, Inc.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# Server Side Public License for more details.
-#
-# You should have received a copy of the Server Side Public License
-# along with this program. If not, see
-# <http://www.mongodb.com/licensing/server-side-public-license>.
-#
-# As a special exception, the copyright holders give permission to link the
-# code of portions of this program with the OpenSSL library under certain
-# conditions as described in each individual source file and distribute
-# linked combinations including the program with the OpenSSL library. You
-# must comply with the Server Side Public License in all respects for
-# all of the code used other than as permitted herein. If you modify file(s)
-# with this exception, you may extend this exception to your version of the
-# file(s), but you are not obligated to do so. If you do not wish to do so,
-# delete this exception statement from your version. If you delete this
-# exception statement from all source files in the program, then also delete
-# it in the license file.
-#
-
-global:
-    cpp_namespace: "mongo"
-
-imports:
-    - "mongo/idl/basic_types.idl"
-
-structs:
-    NamespaceWithOptionalUUID:
-        description: 'Namespace with an optional collection UUID'
-        strict: false
-        fields:
-            ns:
-                description: 'Namespace of the collection'
-                type: namespacestring
-            UUID:
-                description: 'Collection UUID'
-                type: uuid
-                optional: true # optional because the caller may not attach the collection UUID
-
-    CollStatsForBalancing:
-        description: 'Collection stats for a specific collection'
-        strict: false
-        fields:
-            namespace:
-                description: 'Namespace of the collection'
-                type: namespacestring
-                cpp_name: ns
-            collSize:
-                description: 'size of data currently owned by this shard for this collection'
-                type: safeInt64
-
-    ShardsvrGetStatsForBalancingReply:
-        description: 'Response for ShardsvrGetStatsForBalancing command'
-        strict: false
-        fields:
-            stats:
-                description: 'List of stats for each of the requested collection'
-                type: array<CollStatsForBalancing>
-
-commands:
-    _shardsvrGetStatsForBalancing:
-        command_name: _shardsvrGetStatsForBalancing
-        cpp_name: ShardsvrGetStatsForBalancing
-        description: 'Internal command used by the balancer to retrieve stats for balancing.'
-        namespace: ignored
-        api_version: ''
-        strict: false
-        reply_type: ShardsvrGetStatsForBalancingReply
-        fields:
-            collections:
-                description: 'List of namespaces to retrieve statistic for'
-                type: array<NamespaceWithOptionalUUID>
-            scaleFactor:
-                description: 'Scale factor for data size units. If omitted 1048576 (MiB) will be used'
-                type: exactInt64
-                optional: true
diff --git a/src/mongo/s/request_types/merge_chunks_request_test.cpp b/src/mongo/s/request_types/merge_chunks_request_test.cpp
index f7e77f1adaf..b631ca1dffa 100644
--- a/src/mongo/s/request_types/merge_chunks_request_test.cpp
+++ b/src/mongo/s/request_types/merge_chunks_request_test.cpp
@@ -60,12 +60,12 @@ TEST(ConfigSvrMergeChunks, BasicValidConfigCommand) {
 
 TEST(ConfigSvrMergeChunks, ConfigCommandtoBSON) {
     auto collUUID = UUID::gen();
-    BSONObj serializedRequest =
-        BSON("_configsvrCommitChunksMerge"
-             << "TestDB.TestColl"
-             << "shard"
-             << "shard0000"
-             << "collUUID" << collUUID.toBSON() << "chunkRange" << chunkRange.toBSON());
+    BSONObj serializedRequest = BSON("_configsvrCommitChunksMerge"
+                                     << "TestDB.TestColl"
+                                     << "shard"
+                                     << "shard0000"
+                                     << "collUUID" << collUUID.toBSON() << "chunkRange"
+                                     << chunkRange.toBSON() << "validAfter" << Timestamp{100});
     BSONObj writeConcernObj = BSON("w"
                                    << "majority");
 
diff --git a/src/mongo/s/request_types/move_primary.idl b/src/mongo/s/request_types/move_primary.idl
index 4691542c06b..51d4a095b8a 100644
--- a/src/mongo/s/request_types/move_primary.idl
+++ b/src/mongo/s/request_types/move_primary.idl
@@ -33,7 +33,6 @@ global:
 
 imports:
     - "mongo/idl/basic_types.idl"
-    - "mongo/s/sharding_types.idl"
 
 structs:
     movePrimary:
@@ -63,20 +62,3 @@ structs:
             to:
                 type: string
                 description: "The shard serving as the destination for un-sharded collections."
-
-commands:
-    _configsvrCommitMovePrimary:
-        command_name: _configsvrCommitMovePrimary
-        description: Reassign a new primary shard for the given database on the config server
-        cpp_name: ConfigsvrCommitMovePrimary
-        namespace: type
-        type: string
-        api_version:
-        strict: false
-        fields:
-            expectedDatabaseVersion:
-                type: database_version
-                description: Database version known by the current primary shard
-            to:
-                type: shard_id
-                description: Shard serving as the destination for un-sharded collections
diff --git a/src/mongo/s/request_types/sharded_ddl_commands.idl b/src/mongo/s/request_types/sharded_ddl_commands.idl
index 2791c5a1b65..2c86a3d199a 100644
--- a/src/mongo/s/request_types/sharded_ddl_commands.idl
+++ b/src/mongo/s/request_types/sharded_ddl_commands.idl
@@ -315,11 +315,6 @@ commands:
         api_version: ""
         cpp_name: ShardsvrDropCollectionParticipant
         strict: false
-        fields:
-            fromMigrate: 
-                type: bool 
-                description: "Whether the drop comes as a result of an interrupted migration process."
-                optional: true
 
     _shardsvrRenameCollection:
         command_name: _shardsvrRenameCollection
@@ -330,12 +325,6 @@ commands:
         api_version: ""
         chained_structs:
             RenameCollectionRequest: RenameCollectionRequest
-        fields:
-            allowEncryptedCollectionRename:
-                description: "Encrypted Collection renames are usually disallowed to minimize user error.
-                              C2C needs to do the renames to replicate create collection."
-                type: bool
-                optional: true
 
     _shardsvrSetAllowMigrations:
         command_name: _shardsvrSetAllowMigrations
@@ -381,7 +370,7 @@ commands:
         namespace: concatenate_with_db
         api_version: ""
         strict: false
-        chained_structs:
+        chained_structs: 
             RefineCollectionShardKeyRequest: RefineCollectionShardKeyRequest
 
     _configsvrRefineCollectionShardKey:
@@ -414,7 +403,7 @@ commands:
         namespace: concatenate_with_db
         api_version: ""
         strict: false
-        chained_structs:
+        chained_structs: 
             DropIndexesRequest: DropIndexesRequest
 
     _configsvrCreateDatabase:
diff --git a/src/mongo/s/resharding/common_types.idl b/src/mongo/s/resharding/common_types.idl
index 456f96bf811..fb0547b7091 100644
--- a/src/mongo/s/resharding/common_types.idl
+++ b/src/mongo/s/resharding/common_types.idl
@@ -271,13 +271,10 @@ structs:
         description: "A struct representing the information needed for a resharding pipeline to
                       determine which documents belong to a particular shard."
         strict: true
-        query_shape_component: true
         fields:
             recipientShardId:
                 type: shard_id
                 description: "The id of the recipient shard."
-                query_shape: anonymize
             reshardingKey:
                 type: KeyPattern
                 description: "The index specification document to use as the new shard key."
-                query_shape: custom
diff --git a/src/mongo/s/router_role.cpp b/src/mongo/s/router.cpp
index 6fa31d6a447..dba40ad1137 100644
--- a/src/mongo/s/router_role.cpp
+++ b/src/mongo/s/router.cpp
@@ -29,7 +29,7 @@
 
 #define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kSharding
 
-#include "mongo/s/router_role.h"
+#include "mongo/s/router.h"
 
 #include "mongo/logv2/log.h"
 #include "mongo/s/grid.h"
@@ -69,34 +69,32 @@ CachedDatabaseInfo DBPrimaryRouter::_getRoutingInfo(OperationContext* opCtx) con
 }
 
 void DBPrimaryRouter::_onException(RouteContext* context, Status s) {
-    auto catalogCache = Grid::get(_service)->catalogCache();
-
-    if (s == ErrorCodes::StaleDbVersion) {
-        auto si = s.extraInfo<StaleDbRoutingVersion>();
-        tassert(6375900, "StaleDbVersion must have extraInfo", si);
-        tassert(6375901,
-                str::stream() << "StaleDbVersion on unexpected database. Expected " << _db
-                              << ", received " << si->getDb(),
-                si->getDb() == _db);
-
-        catalogCache->onStaleDatabaseVersion(si->getDb(), si->getVersionWanted());
-    } else {
-        uassertStatusOK(s);
-    }
-
     if (++context->numAttempts > kMaxNumStaleVersionRetries) {
         uassertStatusOKWithContext(
             s,
             str::stream() << "Exceeded maximum number of " << kMaxNumStaleVersionRetries
                           << " retries attempting \'" << context->comment << "\'");
     } else {
-        LOGV2_DEBUG(6375902,
+        LOGV2_DEBUG(637590,
                     3,
-                    "Retrying database primary routing operation",
-                    "attempt"_attr = context->numAttempts,
-                    "comment"_attr = context->comment,
+                    "Retrying {description}. Got error: {status}",
+                    "description"_attr = context->comment,
                     "status"_attr = s);
     }
+
+    auto catalogCache = Grid::get(_service)->catalogCache();
+
+    if (s == ErrorCodes::StaleDbVersion) {
+        auto si = s.extraInfo<StaleDbRoutingVersion>();
+        invariant(si);
+        invariant(si->getDb() == _db,
+                  str::stream() << "StaleDbVersion on unexpected database. Expected " << _db
+                                << ", received " << si->getDb());
+
+        catalogCache->onStaleDatabaseVersion(si->getDb(), si->getVersionWanted());
+    } else {
+        uassertStatusOK(s);
+    }
 }
 
 CollectionRouter::CollectionRouter(ServiceContext* service, NamespaceString nss)
@@ -124,39 +122,42 @@ ChunkManager CollectionRouter::_getRoutingInfo(OperationContext* opCtx) const {
 }
 
 void CollectionRouter::_onException(RouteContext* context, Status s) {
-    auto catalogCache = Grid::get(_service)->catalogCache();
-
-    if (s == ErrorCodes::StaleDbVersion) {
-        auto si = s.extraInfo<StaleDbRoutingVersion>();
-        tassert(6375903, "StaleDbVersion must have extraInfo", si);
-        catalogCache->onStaleDatabaseVersion(si->getDb(), si->getVersionWanted());
-    } else if (s == ErrorCodes::StaleConfig) {
-        auto si = s.extraInfo<StaleConfigInfo>();
-        tassert(6375904, "StaleConfig must have extraInfo", si);
-        catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
-            si->getNss(), si->getVersionWanted(), si->getShardId());
-    } else if (s == ErrorCodes::StaleEpoch) {
-        if (auto si = s.extraInfo<StaleEpochInfo>()) {
-            catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
-                si->getNss(), si->getVersionWanted(), ShardId());
-        }
-    } else {
-        uassertStatusOK(s);
-    }
-
     if (++context->numAttempts > kMaxNumStaleVersionRetries) {
         uassertStatusOKWithContext(
             s,
             str::stream() << "Exceeded maximum number of " << kMaxNumStaleVersionRetries
                           << " retries attempting \'" << context->comment << "\'");
     } else {
-        LOGV2_DEBUG(6375906,
+        LOGV2_DEBUG(637591,
                     3,
-                    "Retrying collection routing operation",
-                    "attempt"_attr = context->numAttempts,
-                    "comment"_attr = context->comment,
+                    "Retrying {description}. Got error: {status}",
+                    "description"_attr = context->comment,
                     "status"_attr = s);
     }
+
+    auto catalogCache = Grid::get(_service)->catalogCache();
+
+    if (s.isA<ErrorCategory::StaleShardVersionError>()) {
+        if (auto si = s.extraInfo<StaleConfigInfo>()) {
+            invariant(si->getNss() == _nss,
+                      str::stream() << "StaleConfig on unexpected namespace. Expected " << _nss
+                                    << ", received " << si->getNss());
+            catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
+                _nss, si->getVersionWanted(), si->getShardId());
+        } else {
+            catalogCache->invalidateCollectionEntry_LINEARIZABLE(_nss);
+        }
+    } else if (s == ErrorCodes::StaleDbVersion) {
+        auto si = s.extraInfo<StaleDbRoutingVersion>();
+        invariant(si);
+        invariant(si->getDb() == _nss.db(),
+                  str::stream() << "StaleDbVersion on unexpected database. Expected " << _nss.db()
+                                << ", received " << si->getDb());
+
+        catalogCache->onStaleDatabaseVersion(si->getDb(), si->getVersionWanted());
+    } else {
+        uassertStatusOK(s);
+    }
 }
 
 }  // namespace router
diff --git a/src/mongo/s/router_role.h b/src/mongo/s/router.h
index 6cfd1d9e546..6cfd1d9e546 100644
--- a/src/mongo/s/router_role.h
+++ b/src/mongo/s/router.h
diff --git a/src/mongo/s/routing_table_history_test.cpp b/src/mongo/s/routing_table_history_test.cpp
index 31fd50674ca..9651911ee64 100644
--- a/src/mongo/s/routing_table_history_test.cpp
+++ b/src/mongo/s/routing_table_history_test.cpp
@@ -27,39 +27,20 @@
  *    it in the license file.
  */
 
-#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kTest
-
 #include "mongo/platform/basic.h"
 
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/service_context.h"
-#include "mongo/idl/server_parameter_test_util.h"
-#include "mongo/logv2/log.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/chunk_manager.h"
 #include "mongo/s/chunk_writes_tracker.h"
-#include "mongo/s/chunks_test_util.h"
 #include "mongo/unittest/death_test.h"
 #include "mongo/unittest/unittest.h"
 
-
 namespace mongo {
-
-using chunks_test_util::assertEqualChunkInfo;
-using chunks_test_util::calculateCollVersion;
-using chunks_test_util::calculateIntermediateShardKey;
-using chunks_test_util::calculateShardsMaxValidAfter;
-using chunks_test_util::calculateShardVersions;
-using chunks_test_util::genChunkVector;
-using chunks_test_util::genRandomChunkVector;
-using chunks_test_util::getShardId;
-using chunks_test_util::performRandomChunkOperations;
-
 namespace {
 
-PseudoRandom _random{SecureRandom().nextInt64()};
-
 const ShardId kThisShard("thisShard");
 const NamespaceString kNss("TestDB", "TestColl");
 
@@ -163,57 +144,64 @@ void assertCorrectBytesWritten(const RoutingTableHistory& rt,
     });
 }
 
+/**
+ * Test fixture for tests that need to start with a fresh routing table with
+ * only a single chunk in it, with bytes already written to that chunk object.
+ */
 class RoutingTableHistoryTest : public unittest::Test {
 public:
-    const KeyPattern& getShardKeyPattern() const {
-        return _shardKeyPattern;
+    void setUp() override {
+        const UUID uuid = UUID::gen();
+        const OID epoch = OID::gen();
+        const Timestamp timestamp(1);
+        ChunkVersion version{1, 0, epoch, timestamp};
+
+        auto initChunk =
+            ChunkType{uuid,
+                      ChunkRange{_shardKeyPattern.globalMin(), _shardKeyPattern.globalMax()},
+                      version,
+                      kThisShard};
+
+        _rt.emplace(RoutingTableHistory::makeNew(kNss,
+                                                 uuid,
+                                                 _shardKeyPattern,
+                                                 nullptr,
+                                                 false,
+                                                 epoch,
+                                                 timestamp,
+                                                 boost::none /* timeseriesFields */,
+                                                 boost::none,
+                                                 boost::none /* chunkSizeBytes */,
+                                                 true,
+                                                 {initChunk}));
+        ASSERT_EQ(_rt->numChunks(), 1ull);
+
+        // Should only be one
+        _rt->forEachChunk([&](const auto& chunkInfo) {
+            auto writesTracker = chunkInfo->getWritesTracker();
+            writesTracker->addBytesWritten(_bytesInOriginalChunk);
+            return true;
+        });
     }
 
-    const OID& collEpoch() const {
-        return _epoch;
+    const KeyPattern& getShardKeyPattern() const {
+        return _shardKeyPattern;
     }
 
-    const Timestamp& collTimestamp() const {
-        return _collTimestamp;
+    uint64_t getBytesInOriginalChunk() const {
+        return _bytesInOriginalChunk;
     }
 
-    const UUID& collUUID() const {
-        return _collUUID;
+    const RoutingTableHistory& getInitialRoutingTable() const {
+        return *_rt;
     }
 
-    std::vector<ChunkType> genRandomChunkVector(size_t minNumChunks = 1,
-                                                size_t maxNumChunks = 30) const {
-        return chunks_test_util::genRandomChunkVector(
-            _collUUID, _epoch, _collTimestamp, maxNumChunks, minNumChunks);
-    }
+private:
+    uint64_t _bytesInOriginalChunk{4ull};
 
-    RoutingTableHistory makeNewRt(const std::vector<ChunkType>& chunks) const {
-        const auto chunkBucketSize = llround(_random.nextInt64(chunks.size() * 1.2)) + 1;
-        LOGV2(7162710,
-              "Creating new RoutingTable",
-              "chunkBucketSize"_attr = chunkBucketSize,
-              "numChunks"_attr = chunks.size());
-        RAIIServerParameterControllerForTest chunkBucketSizeParameter(
-            "routingTableCacheChunkBucketSize", chunkBucketSize);
-        return RoutingTableHistory::makeNew(kNss,
-                                            _collUUID,
-                                            _shardKeyPattern,
-                                            nullptr,
-                                            false,
-                                            _epoch,
-                                            _collTimestamp,
-                                            boost::none /* timeseriesFields */,
-                                            boost::none /* reshardingFields */,
-                                            boost::none /* maxChunkSizeBytes */,
-                                            true,
-                                            chunks);
-    }
+    boost::optional<RoutingTableHistory> _rt;
 
-protected:
-    KeyPattern _shardKeyPattern{chunks_test_util::kShardKeyPattern};
-    const OID _epoch{OID::gen()};
-    const Timestamp _collTimestamp{1, 1};
-    const UUID _collUUID{UUID::gen()};
+    KeyPattern _shardKeyPattern{BSON("a" << 1)};
 };
 
 /**
@@ -224,28 +212,13 @@ class RoutingTableHistoryTestThreeInitialChunks : public RoutingTableHistoryTest
 public:
     void setUp() override {
         RoutingTableHistoryTest::setUp();
-
         _initialChunkBoundaryPoints = {getShardKeyPattern().globalMin(),
                                        BSON("a" << 10),
                                        BSON("a" << 20),
                                        getShardKeyPattern().globalMax()};
-        ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
-        auto chunks =
-            genChunkVector(collUUID(), _initialChunkBoundaryPoints, version, 1 /* numShards */);
-
-        _rt.emplace(makeNewRt(chunks));
-
+        _rt.emplace(splitChunk(RoutingTableHistoryTest::getInitialRoutingTable(),
+                               _initialChunkBoundaryPoints));
         ASSERT_EQ(_rt->numChunks(), 3ull);
-
-        _rt->forEachChunk([&](const auto& chunkInfo) {
-            auto writesTracker = chunkInfo->getWritesTracker();
-            writesTracker->addBytesWritten(_bytesInOriginalChunk);
-            return true;
-        });
-    }
-
-    uint64_t getBytesInOriginalChunk() const {
-        return _bytesInOriginalChunk;
     }
 
     const RoutingTableHistory& getInitialRoutingTable() const {
@@ -257,407 +230,24 @@ public:
     }
 
 private:
-    uint64_t _bytesInOriginalChunk{4ull};
-
     boost::optional<RoutingTableHistory> _rt;
 
     std::vector<BSONObj> _initialChunkBoundaryPoints;
 };
 
-/*
- * Test creation of a Routing Table with randomly generated chunks
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateBasic) {
-    const auto chunks = genRandomChunkVector();
-    const auto expectedShardVersions = calculateShardVersions(chunks);
-    const auto expectedCollVersion = calculateCollVersion(expectedShardVersions);
-
-    // Create a new routing table from the randomly generated chunks
-    auto rt = makeNewRt(chunks);
-
-    // Checks basic getter of routing table return correct values
-    ASSERT_EQ(kNss, rt.nss());
-    ASSERT_EQ(ShardKeyPattern(getShardKeyPattern()).toString(), rt.getShardKeyPattern().toString());
-    ASSERT_EQ(chunks.size(), rt.numChunks());
-
-    // Check that chunks have correct info
-    size_t i = 0;
-    rt.forEachChunk([&](const auto& chunkInfo) {
-        assertEqualChunkInfo(ChunkInfo{chunks[i++]}, *chunkInfo);
-        return true;
-    });
-    ASSERT_EQ(i, chunks.size());
-
-    // Checks collection version is correct
-    ASSERT_EQ(expectedCollVersion, rt.getVersion());
-
-    // Checks version for each chunk
-    for (const auto& [shardId, shardVersion] : expectedShardVersions) {
-        ASSERT_EQ(shardVersion, rt.getVersion(shardId));
-    }
-
-    ASSERT_EQ(expectedShardVersions.size(), rt.getNShardsOwningChunks());
-
-    std::set<ShardId> expectedShardIds;
-    for (const auto& [shardId, shardVersion] : expectedShardVersions) {
-        expectedShardIds.insert(shardId);
-    }
-    std::set<ShardId> shardIds;
-    rt.getAllShardIds(&shardIds);
-    ASSERT(expectedShardIds == shardIds);
-
-    // Validate all shard maxValidAfter
-    const auto expectedShardsMaxValidAfter = calculateShardsMaxValidAfter(chunks);
-    const auto expectedMaxValidAfter = [&](const ShardId& shard) {
-        auto it = expectedShardsMaxValidAfter.find(shard);
-        return it != expectedShardsMaxValidAfter.end() ? it->second : Timestamp{0, 0};
-    };
-    for (const auto& [shardId, _] : expectedShardVersions) {
-        ASSERT_GTE(rt.getMaxValidAfter(shardId), expectedMaxValidAfter(shardId));
-    }
-    ASSERT_EQ(rt.getMaxValidAfter(ShardId{"shard-without-chunks"}), (Timestamp{0, 0}));
-}
-
-/*
- * Test that creation of Routing Table with chunks that do not cover the entire shard key space
- * fails.
- *
- * The gap is produced by removing a random chunks from the randomly generated chunk list. Thus it
- * also cover the case for which min/max key is missing.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateWithMissingChunkFail) {
-    auto chunks = genRandomChunkVector(2 /*minNumChunks*/);
-
-    // Remove one random chunk to simulate a gap in the shardkey
-    chunks.erase(chunks.begin() + _random.nextInt64(chunks.size()));
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Test that creation of Routing Table with chunks that do not cover the entire shard key space
- * fails.
- *
- * The gap is produced by shrinking the range of a random chunk.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateWithChunkGapFail) {
-    auto chunks = genRandomChunkVector(2 /*minNumChunks*/);
-
-    auto& shrinkedChunk = chunks.at(_random.nextInt64(chunks.size()));
-    auto intermediateKey =
-        calculateIntermediateShardKey(shrinkedChunk.getMin(), shrinkedChunk.getMax());
-    if (_random.nextInt64(2)) {
-        // Shrink right bound
-        shrinkedChunk.setMax(intermediateKey);
-    } else {
-        // Shrink left bound
-        shrinkedChunk.setMin(intermediateKey);
-    }
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Updating ChunkMap with gaps must fail
- */
-TEST_F(RoutingTableHistoryTest, RandomUpdateWithChunkGapFail) {
-    auto chunks = genRandomChunkVector();
-
-    // Create a new routing table from the randomly generated chunks
-    auto rt = makeNewRt(chunks);
-    auto collVersion = rt.getVersion();
-
-    auto shrinkedChunk = chunks.at(_random.nextInt64(chunks.size()));
-    auto intermediateKey =
-        calculateIntermediateShardKey(shrinkedChunk.getMin(), shrinkedChunk.getMax());
-    if (_random.nextInt64(2)) {
-        // Shrink right bound
-        shrinkedChunk.setMax(intermediateKey);
-    } else {
-        // Shrink left bound
-        shrinkedChunk.setMin(intermediateKey);
-    }
-
-    // Bump chunk version
-    collVersion.incMajor();
-    shrinkedChunk.setVersion(collVersion);
-
-    ASSERT_THROWS_CODE(rt.makeUpdated(boost::none /* timeseriesFields */,
-                                      boost::none /* reshardingFields */,
-                                      boost::none /* maxChunkSizeBytes */,
-                                      true,
-                                      {std::move(shrinkedChunk)}),
-                       AssertionException,
-                       ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Creating a Routing Table with overlapping chunks must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateWithChunkOverlapFail) {
-    auto chunks = genRandomChunkVector(2 /* minNumChunks */);
-
-    auto chunkToExtendIt = chunks.begin() + _random.nextInt64(chunks.size());
-
-    const auto canExtendLeft = chunkToExtendIt > chunks.begin();
-    const auto extendRight =
-        !canExtendLeft || ((chunkToExtendIt < std::prev(chunks.end())) && _random.nextInt64(2));
-    const auto extendLeft = !extendRight;
-    if (extendRight) {
-        // extend right bound
-        chunkToExtendIt->setMax(calculateIntermediateShardKey(chunkToExtendIt->getMax(),
-                                                              std::next(chunkToExtendIt)->getMax(),
-                                                              0.0 /* minKeyProb */,
-                                                              0.1 /* maxKeyProb */));
-        auto newVersion = chunkToExtendIt->getVersion();
-        newVersion.incMajor();
-        std::next(chunkToExtendIt)->setVersion(newVersion);
-    }
-
-    if (extendLeft) {
-        invariant(canExtendLeft);
-        // extend left bound
-        chunkToExtendIt->setMin(calculateIntermediateShardKey(std::prev(chunkToExtendIt)->getMin(),
-                                                              chunkToExtendIt->getMin(),
-                                                              0.1 /* minKeyProb */,
-                                                              0.0 /* maxKeyProb */));
-        auto newVersion = chunkToExtendIt->getVersion();
-        newVersion.incMajor();
-        std::prev(chunkToExtendIt)->setVersion(newVersion);
-    }
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Updating a ChunkMap with overlapping chunks must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomUpdateWithChunkOverlapFail) {
-    auto chunks = genRandomChunkVector(2 /* minNumChunks */);
-
-    // Create a new routing table from the randomly generated chunks
-    auto rt = makeNewRt(chunks);
-    auto collVersion = rt.getVersion();
-
-    auto chunkToExtendIt = chunks.begin() + _random.nextInt64(chunks.size());
-
-    const auto canExtendLeft = chunkToExtendIt > chunks.begin();
-    const auto extendRight =
-        !canExtendLeft || (chunkToExtendIt < std::prev(chunks.end()) && _random.nextInt64(2));
-    const auto extendLeft = !extendRight;
-    if (extendRight) {
-        // extend right bound
-        chunkToExtendIt->setMax(calculateIntermediateShardKey(
-            chunkToExtendIt->getMax(), std::next(chunkToExtendIt)->getMax()));
-    }
-
-    if (extendLeft) {
-        invariant(canExtendLeft);
-        // extend left bound
-        chunkToExtendIt->setMin(calculateIntermediateShardKey(std::prev(chunkToExtendIt)->getMin(),
-                                                              chunkToExtendIt->getMin()));
-    }
-
-    // Bump chunk version
-    collVersion.incMajor();
-    chunkToExtendIt->setVersion(collVersion);
-
-    ASSERT_THROWS_CODE(rt.makeUpdated(boost::none /* timeseriesFields */,
-                                      boost::none /* reshardingFields */,
-                                      boost::none /* maxChunkSizeBytes */,
-                                      true,
-                                      {*chunkToExtendIt}),
-                       AssertionException,
-                       ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Creating a Routing Table with wrong min key must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateWrongMinFail) {
-    auto chunks = genRandomChunkVector();
-
-    chunks.begin()->setMin(BSON("a" << std::numeric_limits<int64_t>::min()));
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Creating a Routing Table with wrong max key must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateWrongMaxFail) {
-    auto chunks = genRandomChunkVector();
-
-    chunks.begin()->setMax(BSON("a" << std::numeric_limits<int64_t>::max()));
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Creating a Routing Table with mismatching epoch must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomCreateMismatchingTimestampFail) {
-    auto chunks = genRandomChunkVector();
-
-    // Change epoch on a random chunk
-    auto chunkIt = chunks.begin() + _random.nextInt64(chunks.size());
-    const auto& oldVersion = chunkIt->getVersion();
-
-    const Timestamp wrongTimestamp{Date_t::now()};
-    ChunkVersion newVersion{
-        oldVersion.majorVersion(), oldVersion.minorVersion(), collEpoch(), wrongTimestamp};
-    chunkIt->setVersion(newVersion);
-
-    // Create a new routing table from the randomly generated chunks
-    ASSERT_THROWS_CODE(makeNewRt(chunks), DBException, ErrorCodes::ConflictingOperationInProgress);
-}
-
-/*
- * Updating a Routing Table with mismatching Timestamp must fail.
- */
-TEST_F(RoutingTableHistoryTest, RandomUpdateMismatchingTimestampFail) {
-    auto chunks = genRandomChunkVector();
-
-    // Create a new routing table from the randomly generated chunks
-    auto rt = makeNewRt(chunks);
-
-    // Change epoch on a random chunk
-    auto chunkIt = chunks.begin() + _random.nextInt64(chunks.size());
-    const auto& oldVersion = chunkIt->getVersion();
-    const Timestamp wrongTimestamp{Date_t::now()};
-    ChunkVersion newVersion{
-        oldVersion.majorVersion(), oldVersion.minorVersion(), collEpoch(), wrongTimestamp};
-    chunkIt->setVersion(newVersion);
-
-    ASSERT_THROWS_CODE(rt.makeUpdated(boost::none /* timeseriesFields */,
-                                      boost::none /* reshardingFields */,
-                                      boost::none /* maxChunkSizeBytes */,
-                                      true,
-                                      {*chunkIt}),
-                       AssertionException,
-                       ErrorCodes::ConflictingOperationInProgress);
-}
-
-
-/*
- * Test update of the Routing Table with randomly generated changed chunks.
- */
-TEST_F(RoutingTableHistoryTest, RandomUpdate) {
-    auto initialChunks = genRandomChunkVector();
-
-    const auto initialShardVersions = calculateShardVersions(initialChunks);
-    const auto initialCollVersion = calculateCollVersion(initialShardVersions);
-
-    // Create a new routing table from the randomly generated initialChunks
-    auto initialRt = makeNewRt(initialChunks);
-
-    auto chunks = initialChunks;
-    const auto maxNumChunkOps = 2 * initialChunks.size();
-    const auto numChunkOps = _random.nextInt32(maxNumChunkOps);
-
-    performRandomChunkOperations(&chunks, numChunkOps);
-
-    std::vector<ChunkType> updatedChunks;
-    for (const auto& chunk : chunks) {
-        if (!chunk.getVersion().isOlderOrEqualThan(initialCollVersion)) {
-            updatedChunks.push_back(chunk);
-        }
-    }
-
-    const auto expectedShardVersions = calculateShardVersions(chunks);
-    const auto expectedCollVersion = calculateCollVersion(expectedShardVersions);
-
-    auto rt = initialRt.makeUpdated(boost::none /* timeseriesFields */,
-                                    boost::none /* reshardingFields */,
-                                    boost::none /* maxChunkSizeBytes */,
-                                    true,
-                                    updatedChunks);
-
-    // Checks basic getter of routing table return correct values
-    ASSERT_EQ(kNss, rt.nss());
-    ASSERT_EQ(ShardKeyPattern(getShardKeyPattern()).toString(), rt.getShardKeyPattern().toString());
-    ASSERT_EQ(chunks.size(), rt.numChunks());
-
-    // Check that chunks have correct info
-    size_t i = 0;
-    rt.forEachChunk([&](const auto& chunkInfo) {
-        assertEqualChunkInfo(ChunkInfo{chunks[i++]}, *chunkInfo);
-        return true;
-    });
-    ASSERT_EQ(i, chunks.size());
-
-    // Checks collection version is correct
-    ASSERT_EQ(expectedCollVersion, rt.getVersion());
-
-    // Checks version for each shard
-    for (const auto& [shardId, shardVersion] : expectedShardVersions) {
-        ASSERT_EQ(shardVersion, rt.getVersion(shardId));
-    }
-
-    ASSERT_EQ(expectedShardVersions.size(), rt.getNShardsOwningChunks());
-
-    std::set<ShardId> expectedShardIds;
-    for (const auto& [shardId, shardVersion] : expectedShardVersions) {
-        expectedShardIds.insert(shardId);
-    }
-    std::set<ShardId> shardIds;
-    rt.getAllShardIds(&shardIds);
-    ASSERT(expectedShardIds == shardIds);
-
-    // Validate all shard maxValidAfter
-    const auto expectedShardsMaxValidAfter = calculateShardsMaxValidAfter(chunks);
-    const auto expectedMaxValidAfter = [&](const ShardId& shard) {
-        auto it = expectedShardsMaxValidAfter.find(shard);
-        return it != expectedShardsMaxValidAfter.end() ? it->second : Timestamp{0, 0};
-    };
-    for (const auto& [shardId, _] : expectedShardVersions) {
-        ASSERT_GTE(rt.getMaxValidAfter(shardId), expectedMaxValidAfter(shardId))
-            << "For shardid " << shardId;
-    }
-    ASSERT_EQ(rt.getMaxValidAfter(ShardId{"shard-without-chunks"}), (Timestamp{0, 0}));
-}
-
 TEST_F(RoutingTableHistoryTest, SplittingOnlyChunkCopiesBytesWrittenToAllSubchunks) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
-
-    const ChunkType initialChunk{
-        collUUID(),
-        ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
-        version,
-        kThisShard};
+    auto minKey = BSON("a" << 10);
+    auto maxKey = BSON("a" << 20);
+    auto newChunkBoundaryPoints = {
+        getShardKeyPattern().globalMin(), minKey, maxKey, getShardKeyPattern().globalMax()};
 
-    auto rt = makeNewRt({initialChunk});
-    ASSERT_EQ(1, rt.numChunks());
-
-    // Set the 4 written bytes in each chunk
-    const size_t bytesInOriginalChunk{4};
-    rt.forEachChunk([&](const auto& chunkInfo) {
-        chunkInfo->getWritesTracker()->addBytesWritten(bytesInOriginalChunk);
-        return true;
-    });
-
-    version.incMinor();
-    auto newChunks = genChunkVector(collUUID(),
-                                    {getShardKeyPattern().globalMin(),
-                                     BSON("a" << 10),
-                                     BSON("a" << 20),
-                                     getShardKeyPattern().globalMax()},
-                                    version,
-                                    1 /*numShards*/);
-    auto newRt = rt.makeUpdated(boost::none /* timeseriesFields */,
-                                boost::none /* reshardingFields */,
-                                boost::none /* maxChunkSizeBytes */,
-                                true,
-                                newChunks);
-    ASSERT_EQ(3, newRt.numChunks());
+    auto rt = splitChunk(getInitialRoutingTable(), newChunkBoundaryPoints);
+    ASSERT_EQ(rt.numChunks(), 3ull);
 
     rt.forEachChunk([&](const auto& chunkInfo) {
-        ASSERT_EQ(bytesInOriginalChunk, chunkInfo->getWritesTracker()->getBytesWritten());
+        auto writesTracker = chunkInfo->getWritesTracker();
+        auto bytesWritten = writesTracker->getBytesWritten();
+        ASSERT_EQ(bytesWritten, getBytesInOriginalChunk());
         return true;
     });
 }
@@ -738,124 +328,104 @@ TEST_F(RoutingTableHistoryTestThreeInitialChunks,
                               expectedBytesInChunksNotSplit);
 }
 
-TEST_F(RoutingTableHistoryTest, AllowMigrationFlag) {
-    auto chunks = genRandomChunkVector();
-
-    auto makeUpdatedChunk = [&](const ChunkVersion& oldVersion) {
-        auto updatedChunk = chunks[_random.nextInt64(chunks.size())];
-        updatedChunk.setVersion({oldVersion.majorVersion() + 1,
-                                 oldVersion.minorVersion(),
-                                 collEpoch(),
-                                 collTimestamp()});
-        return updatedChunk;
-    };
-
-    for (auto initialAllowMigrationsValue : std::vector<bool>{false, true}) {
-
-        auto allowMigrationsValue = initialAllowMigrationsValue;
-        auto rt = RoutingTableHistory::makeNew(kNss,
-                                               collUUID(),
-                                               getShardKeyPattern(),
-                                               nullptr,
-                                               false,
-                                               collEpoch(),
-                                               collTimestamp(),
-                                               boost::none /* timeseriesFields */,
-                                               boost::none /* reshardingFields */,
-                                               boost::none /* maxChunkSizeBytes */,
-                                               allowMigrationsValue,
-                                               chunks);
-        ASSERT_EQ(allowMigrationsValue, rt.allowMigrations());
-
-        // Create an updated routing table with flipped allowMigration flag
-        allowMigrationsValue = !allowMigrationsValue;
-        rt = rt.makeUpdated(boost::none /* timeseriesFields */,
-                            boost::none /* reshardingFields */,
-                            boost::none /* maxChunkSizeBytes */,
-                            allowMigrationsValue,
-                            {makeUpdatedChunk(rt.getVersion())});
-        ASSERT_EQ(allowMigrationsValue, rt.allowMigrations());
-
-        // Change back the allow migration flag to the original value
-        allowMigrationsValue = !allowMigrationsValue;
-        rt = rt.makeUpdated(boost::none /* timeseriesFields */,
-                            boost::none /* reshardingFields */,
-                            boost::none /* maxChunkSizeBytes */,
-                            allowMigrationsValue,
-                            {makeUpdatedChunk(rt.getVersion())});
-        ASSERT_EQ(allowMigrationsValue, rt.allowMigrations());
-    }
-}
-
 TEST_F(RoutingTableHistoryTest, TestSplits) {
-    ChunkVersion version{1, 0, collEpoch(), collTimestamp()};
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+    ChunkVersion version{1, 0, epoch, timestamp};
 
     auto chunkAll =
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
                   version,
                   kThisShard};
 
-    auto rt = makeNewRt({chunkAll});
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           {chunkAll});
 
     std::vector<ChunkType> chunks1 = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 =
         rt.makeUpdated(boost::none /* timeseriesFields */, boost::none, boost::none, true, chunks1);
-    auto v1 = ChunkVersion{2, 2, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{2, 2, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
 
     std::vector<ChunkType> chunks2 = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << -1)},
-                  ChunkVersion{3, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << -1), BSON("a" << 0)},
-                  ChunkVersion{3, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 2, epoch, timestamp},
                   kThisShard}};
 
     auto rt2 = rt1.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, chunks2);
-    auto v2 = ChunkVersion{3, 2, collEpoch(), collTimestamp()};
+    auto v2 = ChunkVersion{3, 2, epoch, timestamp};
     ASSERT_EQ(v2, rt2.getVersion(kThisShard));
 }
 
 TEST_F(RoutingTableHistoryTest, TestReplaceEmptyChunk) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
-                  ChunkVersion{1, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{1, 0, epoch, timestamp},
                   kThisShard}};
 
-    auto rt = makeNewRt(initialChunks);
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 1);
 
     std::vector<ChunkType> changedChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 = rt.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, changedChunks);
-    auto v1 = ChunkVersion{2, 2, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{2, 2, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
     ASSERT_EQ(rt1.numChunks(), 2);
 
@@ -874,184 +444,258 @@ TEST_F(RoutingTableHistoryTest, TestReplaceEmptyChunk) {
 }
 
 TEST_F(RoutingTableHistoryTest, TestUseLatestVersions) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
-                  ChunkVersion{1, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{1, 0, epoch, timestamp},
                   kThisShard}};
 
-    auto rt = makeNewRt(initialChunks);
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 1);
 
     std::vector<ChunkType> changedChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
-                  ChunkVersion{1, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{1, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 = rt.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, changedChunks);
-    auto v1 = ChunkVersion{2, 2, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{2, 2, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
     ASSERT_EQ(rt1.numChunks(), 2);
 }
 
 TEST_F(RoutingTableHistoryTest, TestOutOfOrderVersion) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
-    auto rt = makeNewRt(initialChunks);
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 2);
 
     std::vector<ChunkType> changedChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), getShardKeyPattern().globalMax()},
-                  ChunkVersion{3, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{3, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 1, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 = rt.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, changedChunks);
-    auto v1 = ChunkVersion{3, 1, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{3, 1, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
     ASSERT_EQ(rt1.numChunks(), 2);
 
     auto chunk1 = rt1.findIntersectingChunk(BSON("a" << 0));
-    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(3, 0, collEpoch(), collTimestamp()));
+    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(3, 0, epoch, timestamp));
     ASSERT_EQ(chunk1->getMin().woCompare(BSON("a" << 0)), 0);
     ASSERT_EQ(chunk1->getMax().woCompare(getShardKeyPattern().globalMax()), 0);
 }
 
 TEST_F(RoutingTableHistoryTest, TestMergeChunks) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 0), BSON("a" << 10)},
-                  ChunkVersion{2, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 0)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 10), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
-    auto rt = makeNewRt(initialChunks);
-
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 3);
-    ASSERT_EQ(rt.getVersion(), ChunkVersion(2, 2, collEpoch(), collTimestamp()));
+    ASSERT_EQ(rt.getVersion(), ChunkVersion(2, 2, epoch, timestamp));
 
     std::vector<ChunkType> changedChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 10), getShardKeyPattern().globalMax()},
-                  ChunkVersion{3, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 10)},
-                  ChunkVersion{3, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 1, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 = rt.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, changedChunks);
-    auto v1 = ChunkVersion{3, 1, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{3, 1, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
     ASSERT_EQ(rt1.numChunks(), 2);
 }
 
 TEST_F(RoutingTableHistoryTest, TestMergeChunksOrdering) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << -10), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << -500)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << -500), BSON("a" << -10)},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard}};
 
-    auto rt = makeNewRt(initialChunks);
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           uuid,
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 3);
-    ASSERT_EQ(rt.getVersion(), ChunkVersion(2, 2, collEpoch(), collTimestamp()));
+    ASSERT_EQ(rt.getVersion(), ChunkVersion(2, 2, epoch, timestamp));
 
     std::vector<ChunkType> changedChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << -500), BSON("a" << -10)},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << -10)},
-                  ChunkVersion{3, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 1, epoch, timestamp},
                   kThisShard}};
 
     auto rt1 = rt.makeUpdated(
         boost::none /* timeseriesFields */, boost::none, boost::none, true, changedChunks);
-    auto v1 = ChunkVersion{3, 1, collEpoch(), collTimestamp()};
+    auto v1 = ChunkVersion{3, 1, epoch, timestamp};
     ASSERT_EQ(v1, rt1.getVersion(kThisShard));
     ASSERT_EQ(rt1.numChunks(), 2);
 
     auto chunk1 = rt1.findIntersectingChunk(BSON("a" << -500));
-    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(3, 1, collEpoch(), collTimestamp()));
+    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(3, 1, epoch, timestamp));
     ASSERT_EQ(chunk1->getMin().woCompare(getShardKeyPattern().globalMin()), 0);
     ASSERT_EQ(chunk1->getMax().woCompare(BSON("a" << -10)), 0);
 }
 
 TEST_F(RoutingTableHistoryTest, TestFlatten) {
+    const UUID uuid = UUID::gen();
+    const OID epoch = OID::gen();
+    const Timestamp timestamp(1);
+
     std::vector<ChunkType> initialChunks = {
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 10)},
-                  ChunkVersion{2, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 10), BSON("a" << 20)},
-                  ChunkVersion{2, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 1, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 20), getShardKeyPattern().globalMax()},
-                  ChunkVersion{2, 2, collEpoch(), collTimestamp()},
+                  ChunkVersion{2, 2, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), getShardKeyPattern().globalMax()},
-                  ChunkVersion{3, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{3, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{getShardKeyPattern().globalMin(), BSON("a" << 10)},
-                  ChunkVersion{4, 0, collEpoch(), collTimestamp()},
+                  ChunkVersion{4, 0, epoch, timestamp},
                   kThisShard},
-        ChunkType{collUUID(),
+        ChunkType{uuid,
                   ChunkRange{BSON("a" << 10), getShardKeyPattern().globalMax()},
-                  ChunkVersion{4, 1, collEpoch(), collTimestamp()},
+                  ChunkVersion{4, 1, epoch, timestamp},
                   kThisShard},
     };
 
-    auto rt = makeNewRt(initialChunks);
+    auto rt = RoutingTableHistory::makeNew(kNss,
+                                           UUID::gen(),
+                                           getShardKeyPattern(),
+                                           nullptr,
+                                           false,
+                                           epoch,
+                                           timestamp,
+                                           boost::none /* timeseriesFields */,
+                                           boost::none,
+                                           boost::none /* chunkSizeBytes */,
+                                           true,
+                                           initialChunks);
     ASSERT_EQ(rt.numChunks(), 2);
-    ASSERT_EQ(rt.getVersion(), ChunkVersion(4, 1, collEpoch(), collTimestamp()));
+    ASSERT_EQ(rt.getVersion(), ChunkVersion(4, 1, epoch, timestamp));
 
     auto chunk1 = rt.findIntersectingChunk(BSON("a" << 0));
-    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(4, 0, collEpoch(), collTimestamp()));
+    ASSERT_EQ(chunk1->getLastmod(), ChunkVersion(4, 0, epoch, timestamp));
     ASSERT_EQ(chunk1->getMin().woCompare(getShardKeyPattern().globalMin()), 0);
     ASSERT_EQ(chunk1->getMax().woCompare(BSON("a" << 10)), 0);
 }
diff --git a/src/mongo/s/service_entry_point_mongos.cpp b/src/mongo/s/service_entry_point_mongos.cpp
index d704c3c1354..12ebf1299bd 100644
--- a/src/mongo/s/service_entry_point_mongos.cpp
+++ b/src/mongo/s/service_entry_point_mongos.cpp
@@ -219,7 +219,7 @@ void ServiceEntryPointMongos::onClientConnect(Client* client) {
     }
 }
 
-void ServiceEntryPointMongos::onClientDisconnect(Client* client) try {
+void ServiceEntryPointMongos::onClientDisconnect(Client* client) {
     if (load_balancer_support::isFromLoadBalancer(client)) {
         _loadBalancedConnections.decrement();
 
@@ -259,11 +259,6 @@ void ServiceEntryPointMongos::onClientDisconnect(Client* client) try {
                  "aborting in-progress transaction because load-balanced client disconnected"});
         }
     }
-} catch (const DBException& ex) {
-    LOGV2_DEBUG(8969800,
-                2,
-                "Encountered error while performing client connection cleanup",
-                "error"_attr = ex.toStatus());
 }
 
 void ServiceEntryPointMongos::appendStats(BSONObjBuilder* bob) const {
diff --git a/src/mongo/s/sessions_collection_sharded_test.cpp b/src/mongo/s/sessions_collection_sharded_test.cpp
index b8cd82617e5..d82a4edfbfa 100644
--- a/src/mongo/s/sessions_collection_sharded_test.cpp
+++ b/src/mongo/s/sessions_collection_sharded_test.cpp
@@ -34,7 +34,6 @@
 #include "mongo/client/remote_command_targeter_mock.h"
 #include "mongo/db/commands.h"
 #include "mongo/db/logical_session_id.h"
-#include "mongo/db/query/cursor_response.h"
 #include "mongo/s/catalog/type_shard.h"
 #include "mongo/s/catalog_cache_test_fixture.h"
 #include "mongo/s/client/shard_registry.h"
diff --git a/src/mongo/s/shard_id_test.cpp b/src/mongo/s/shard_id_test.cpp
index 1182d429e26..08765eeff91 100644
--- a/src/mongo/s/shard_id_test.cpp
+++ b/src/mongo/s/shard_id_test.cpp
@@ -88,8 +88,8 @@ TEST(ShardId, Compare) {
     ShardId sa1(a1);
     ShardId sb(b);
     ASSERT_EQUALS(sa.compare(sa1), a.compare(a1));
-    ASSERT_EQUALS(sb.compare(sa1) > 0, b.compare(a1) > 0);
-    ASSERT_EQUALS(sa.compare(sb) < 0, a.compare(b) < 0);
+    ASSERT_EQUALS(sb.compare(sa1), b.compare(a1));
+    ASSERT_EQUALS(sa.compare(sb), a.compare(b));
 }
 
 TEST(ShardId, Equals) {
diff --git a/src/mongo/s/shard_key_pattern.cpp b/src/mongo/s/shard_key_pattern.cpp
index 9e6f3244dcd..c8fb1b7a84c 100644
--- a/src/mongo/s/shard_key_pattern.cpp
+++ b/src/mongo/s/shard_key_pattern.cpp
@@ -33,7 +33,6 @@
 
 #include <vector>
 
-#include "mongo/bson/simple_bsonelement_comparator.h"
 #include "mongo/db/field_ref.h"
 #include "mongo/db/field_ref_set.h"
 #include "mongo/db/hasher.h"
@@ -86,20 +85,10 @@ std::vector<std::unique_ptr<FieldRef>> parseShardKeyPattern(const BSONObj& keyPa
 
         // Empty parts of the path, ".."?
         for (size_t i = 0; i < newFieldRef->numParts(); ++i) {
-            const StringData part = newFieldRef->getPart(i);
-
             uassert(ErrorCodes::BadValue,
                     str::stream() << "Field " << patternEl.fieldNameStringData()
                                   << " contains empty parts",
-                    !part.empty());
-
-            // Reject a shard key that has a field name that starts with '$' or contains parts that
-            // start with '$' unless the part is a DBRef (i.e. is equal to '$id', '$db' or '$ref').
-            uassert(ErrorCodes::BadValue,
-                    str::stream() << "Field " << patternEl.fieldNameStringData()
-                                  << " contains parts that start with '$'",
-                    !part.startsWith("$") ||
-                        (i != 0 && (part == "$db" || part == "$id" || part == "$ref")));
+                    !newFieldRef->getPart(i).empty());
         }
 
         // Numeric and ascending (1.0), or "hashed" with exactly hashed field.
@@ -299,7 +288,7 @@ bool ShardKeyPattern::isShardKey(const BSONObj& shardKey) const {
 }
 
 bool ShardKeyPattern::isExtendedBy(const ShardKeyPattern& newShardKeyPattern) const {
-    return toBSON().isPrefixOf(newShardKeyPattern.toBSON(), SimpleBSONElementComparator::kInstance);
+    return toBSON().isFieldNamePrefixOf(newShardKeyPattern.toBSON());
 }
 
 BSONObj ShardKeyPattern::normalizeShardKey(const BSONObj& shardKey) const {
@@ -555,12 +544,12 @@ BSONObj ShardKeyPattern::extractShardKeyFromQuery(const CanonicalQuery& query) c
     return keyBuilder.obj();
 }
 
-bool ShardKeyPattern::isIndexUniquenessCompatible(const BSONObj& indexPattern) const {
-    if (!indexPattern.isEmpty() && indexPattern.firstElementFieldName() == kIdField) {
+bool ShardKeyPattern::isUniqueIndexCompatible(const BSONObj& uniqueIndexPattern) const {
+    if (!uniqueIndexPattern.isEmpty() && uniqueIndexPattern.firstElementFieldName() == kIdField) {
         return true;
     }
 
-    return _keyPattern.toBSON().isFieldNamePrefixOf(indexPattern);
+    return _keyPattern.toBSON().isFieldNamePrefixOf(uniqueIndexPattern);
 }
 
 BoundList ShardKeyPattern::flattenBounds(const IndexBounds& indexBounds) const {
diff --git a/src/mongo/s/shard_key_pattern.h b/src/mongo/s/shard_key_pattern.h
index 70f5aff336d..545d1906e31 100644
--- a/src/mongo/s/shard_key_pattern.h
+++ b/src/mongo/s/shard_key_pattern.h
@@ -274,37 +274,36 @@ public:
     BSONObj extractShardKeyFromQuery(const CanonicalQuery& query) const;
 
     /**
-     * Returns true if the shard key pattern can ensure that the index uniqueness is respected
-     * across all shards.
+     * Returns true if the shard key pattern can ensure that the unique index pattern is
+     * respected across all shards.
      *
      * Primarily this just checks whether the shard key pattern field names are equal to or a
-     * prefix of the 'unique' or 'prepareUnique' index pattern field names. Since documents with the
-     * same fields in the shard key pattern are guaranteed to go to the same shard, and all
-     * documents must contain the full shard key, an index with {unique: true} or {prepareUnique:
-     * true} and a shard key pattern prefix can be sure when resolving duplicates that documents on
-     * other shards will have different shard keys, and so are not duplicates.
+     * prefix of the unique index pattern field names.  Since documents with the same fields in
+     * the shard key pattern are guaranteed to go to the same shard, and all documents must
+     * contain the full shard key, a unique index with a shard key pattern prefix can be sure
+     * when resolving duplicates that documents on other shards will have different shard keys,
+     * and so are not duplicates.
      *
      * Hashed shard key patterns are similar to ordinary patterns in that they guarantee similar
      * shard keys go to the same shard.
      *
      * Examples:
-     *     shard key {a : 1} is compatible with a unique/prepareUnique index on {_id : 1}
-     *     shard key {a : 1} is compatible with a unique/prepareUnique index on {a : 1, b : 1}
-     *     shard key {a : 1} is compatible with a unique/prepareUnique index on {a : -1, b : 1}
-     *     shard key {a : "hashed"} is compatible with a unique/prepareUnique index on {a : 1}
-     *     shard key {a : 1} is not compatible with a unique/prepareUnique index on {b : 1}
-     *     shard key {a : "hashed", b : 1} is not compatible with unique/prepareUnique index on
-     *     {b : 1}
+     *     shard key {a : 1} is compatible with a unique index on {_id : 1}
+     *     shard key {a : 1} is compatible with a unique index on {a : 1 , b : 1}
+     *     shard key {a : 1} is compatible with a unique index on {a : -1 , b : 1 }
+     *     shard key {a : "hashed"} is compatible with a unique index on {a : 1}
+     *     shard key {a : 1} is not compatible with a unique index on {b : 1}
+     *     shard key {a : "hashed" , b : 1 } is not compatible with unique index on { b : 1 }
      *
      * All unique index patterns starting with _id are assumed to be enforceable by the fact
      * that _ids must be unique, and so all unique _id prefixed indexes are compatible with
      * any shard key pattern.
      *
-     * NOTE: We assume 'indexPattern' is a valid unique/prepareUnique index pattern - a pattern like
-     * { k : "hashed" } is not capable of being a unique/prepareUnique index and is an invalid
-     * argument to this method.
+     * NOTE: We assume 'uniqueIndexPattern' is a valid unique index pattern - a pattern like
+     * { k : "hashed" } is not capable of being a unique index and is an invalid argument to
+     * this method.
      */
-    bool isIndexUniquenessCompatible(const BSONObj& indexPattern) const;
+    bool isUniqueIndexCompatible(const BSONObj& uniqueIndexPattern) const;
 
     /**
      * Return an ordered list of bounds generated using this KeyPattern and the
diff --git a/src/mongo/s/shard_key_pattern_test.cpp b/src/mongo/s/shard_key_pattern_test.cpp
index e001e5cb55e..2965b5d6222 100644
--- a/src/mongo/s/shard_key_pattern_test.cpp
+++ b/src/mongo/s/shard_key_pattern_test.cpp
@@ -78,7 +78,6 @@ repl::OplogEntry makeOplogEntry(repl::OpTime opTime,
                                 nss,                              // namespace
                                 boost::none,                      // uuid
                                 boost::none,                      // fromMigrate
-                                boost::none,                      // checkExistenceForDiffInsert
                                 repl::OplogEntry::kOplogVersion,  // version
                                 oField,                           // o
                                 o2Field,                          // o2
@@ -100,7 +99,6 @@ TEST_F(ShardKeyPatternTest, SingleFieldShardKeyPatternsValidityCheck) {
     ShardKeyPattern s3(BSON("a" << (long long)1L));
     ShardKeyPattern s4(BSON("a"
                             << "hashed"));
-    ShardKeyPattern s5(BSON("a$" << 1));
 
     ASSERT_THROWS(ShardKeyPattern(BSONObj()), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << -1)), DBException);
@@ -113,21 +111,12 @@ TEST_F(ShardKeyPatternTest, SingleFieldShardKeyPatternsValidityCheck) {
                   DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("" << 1)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("." << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$a" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$**" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$id" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$db" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("$ref" << 1)), DBException);
 }
 
 TEST_F(ShardKeyPatternTest, CompositeShardKeyPatternsValidityCheck) {
     ShardKeyPattern s1(BSON("a" << 1 << "b" << 1));
     ShardKeyPattern s2(BSON("a" << 1.0f << "b" << 1.0));
     ShardKeyPattern s3(BSON("a" << 1 << "b" << 1.0 << "c" << 1.0f));
-    ShardKeyPattern s4(BSON("a.$id" << 1));
-    ShardKeyPattern s5(BSON("a.$db" << 1));
-    ShardKeyPattern s6(BSON("a.$ref" << 1));
 
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "b" << -1)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "b"
@@ -135,9 +124,6 @@ TEST_F(ShardKeyPatternTest, CompositeShardKeyPatternsValidityCheck) {
                   DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "b." << 1.0)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "" << 1.0)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "$" << 1.0)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "$b" << 1.0)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "$**" << 1.0)), DBException);
 }
 
 TEST_F(ShardKeyPatternTest, NestedShardKeyPatternsValidtyCheck) {
@@ -145,7 +131,6 @@ TEST_F(ShardKeyPatternTest, NestedShardKeyPatternsValidtyCheck) {
     ShardKeyPattern s2(BSON("a.b.c.d" << 1.0));
     ShardKeyPattern s3(BSON("a" << 1 << "c.d" << 1.0 << "e.f.g" << 1.0f));
     ShardKeyPattern s4(BSON("a" << 1 << "a.b" << 1.0 << "a.b.c" << 1.0f));
-    ShardKeyPattern s6(BSON("a.b$" << 1));
 
     ASSERT_THROWS(ShardKeyPattern(BSON("a.b" << -1)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << BSON("b" << 1))), DBException);
@@ -154,9 +139,6 @@ TEST_F(ShardKeyPatternTest, NestedShardKeyPatternsValidtyCheck) {
     ASSERT_THROWS(ShardKeyPattern(BSON("a..b" << 1)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << 1 << "a.b." << 1.0)), DBException);
     ASSERT_THROWS(ShardKeyPattern(BSON("a" << BSON("b" << 1) << "c.d" << 1.0)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a.$" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a.$b" << 1)), DBException);
-    ASSERT_THROWS(ShardKeyPattern(BSON("a.$**" << 1)), DBException);
 }
 
 TEST_F(ShardKeyPatternTest, IsShardKey) {
@@ -626,7 +608,7 @@ TEST_F(ShardKeyPatternTest, ExtractQueryShardKeyHashed) {
 }
 
 static bool indexComp(const ShardKeyPattern& pattern, const BSONObj& indexPattern) {
-    return pattern.isIndexUniquenessCompatible(indexPattern);
+    return pattern.isUniqueIndexCompatible(indexPattern);
 }
 
 TEST_F(ShardKeyPatternTest, UniqueIndexCompatibleSingle) {
@@ -1034,83 +1016,5 @@ TEST_F(ShardKeyPatternTest, ExtractShardKeyFromDocumentKey_Hashed) {
         BSONObj());
 }
 
-TEST_F(ShardKeyPatternTest, IsExtendedBy) {
-
-    // NumberOfFields
-    ShardKeyPattern shardKeyPattern1(BSON("a" << 1));
-    ShardKeyPattern shardKeyPattern2(BSON("a" << 1 << "b" << 1));
-    ShardKeyPattern shardKeyPattern3(BSON("a" << 1 << "b" << 1 << "c" << 1));
-
-    // NumberOfFields_PositionOfHash
-    ShardKeyPattern shardKeyPatternHashed1_0(BSON("a"
-                                                  << "hashed"));
-    ShardKeyPattern shardKeyPatternHashed2_0(BSON("a"
-                                                  << "hashed"
-                                                  << "b" << 1));
-    ShardKeyPattern shardKeyPatternHashed2_1(BSON("a" << 1 << "b"
-                                                      << "hashed"));
-    ShardKeyPattern shardKeyPatternHashed3_0(BSON("a"
-                                                  << "hashed"
-                                                  << "b" << 1 << "c" << 1));
-    ShardKeyPattern shardKeyPatternHashed3_1(BSON("a" << 1 << "b"
-                                                      << "hashed"
-                                                      << "c" << 1));
-    ShardKeyPattern shardKeyPatternHashed3_2(BSON("a" << 1 << "b" << 1 << "c"
-                                                      << "hashed"));
-
-    // same pattern, always true
-    ASSERT_TRUE(shardKeyPattern1.isExtendedBy(shardKeyPattern1));
-    ASSERT_TRUE(shardKeyPattern2.isExtendedBy(shardKeyPattern2));
-    ASSERT_TRUE(shardKeyPattern3.isExtendedBy(shardKeyPattern3));
-    ASSERT_TRUE(shardKeyPatternHashed1_0.isExtendedBy(shardKeyPatternHashed1_0));
-    ASSERT_TRUE(shardKeyPatternHashed2_0.isExtendedBy(shardKeyPatternHashed2_0));
-    ASSERT_TRUE(shardKeyPatternHashed2_1.isExtendedBy(shardKeyPatternHashed2_1));
-    ASSERT_TRUE(shardKeyPatternHashed3_0.isExtendedBy(shardKeyPatternHashed3_0));
-    ASSERT_TRUE(shardKeyPatternHashed3_1.isExtendedBy(shardKeyPatternHashed3_1));
-    ASSERT_TRUE(shardKeyPatternHashed3_2.isExtendedBy(shardKeyPatternHashed3_2));
-
-    // different number of fields, same values
-    ASSERT_TRUE(shardKeyPattern1.isExtendedBy(shardKeyPattern2));
-    ASSERT_TRUE(shardKeyPattern2.isExtendedBy(shardKeyPattern3));
-    ASSERT_TRUE(shardKeyPattern1.isExtendedBy(shardKeyPattern3));
-
-    ASSERT_FALSE(shardKeyPattern2.isExtendedBy(shardKeyPattern1));
-    ASSERT_FALSE(shardKeyPattern3.isExtendedBy(shardKeyPattern2));
-    ASSERT_FALSE(shardKeyPattern3.isExtendedBy(shardKeyPattern1));
-
-    // different number of fields, different values
-    // { a : 1 } is not extended by { a : "hashed" } and viceversa
-    ASSERT_FALSE(shardKeyPattern1.isExtendedBy(shardKeyPatternHashed1_0));
-    ASSERT_FALSE(shardKeyPatternHashed1_0.isExtendedBy(shardKeyPattern1));
-
-    // { a : 1, b : 1 } is not extended by { a : 1, b : "hashed" } and viceversa
-    ASSERT_FALSE(shardKeyPattern2.isExtendedBy(shardKeyPatternHashed2_1));
-    ASSERT_FALSE(shardKeyPatternHashed2_1.isExtendedBy(shardKeyPattern2));
-
-    // { a : 1 } is extended by { a : 1, b : "hashed" } but not viceversa
-    ASSERT_TRUE(shardKeyPattern1.isExtendedBy(shardKeyPatternHashed2_1));
-    ASSERT_FALSE(shardKeyPatternHashed2_1.isExtendedBy(shardKeyPattern1));
-
-    // { a : 1, b : 1 } is extended by { a : 1, b : 1, c : "hashed" } but not viceversa
-    ASSERT_TRUE(shardKeyPattern2.isExtendedBy(shardKeyPatternHashed3_2));
-    ASSERT_FALSE(shardKeyPatternHashed3_2.isExtendedBy(shardKeyPattern2));
-
-    // { a : 1, b : 1, c : 1 } is not extended by { a : 1, b : 1, c : "hashed" } and viceversa
-    ASSERT_FALSE(shardKeyPattern3.isExtendedBy(shardKeyPatternHashed3_2));
-    ASSERT_FALSE(shardKeyPatternHashed3_2.isExtendedBy(shardKeyPattern3));
-
-    // { a: "hashed", b : 1 } is not extended by { a : 1, b : 1, c : "hashed" } and viceversa
-    ASSERT_FALSE(shardKeyPatternHashed2_1.isExtendedBy(shardKeyPatternHashed3_2));
-    ASSERT_FALSE(shardKeyPatternHashed3_2.isExtendedBy(shardKeyPatternHashed2_1));
-
-    // { a : "hashed", b : 1 } is extended by { a : "hashed", b : 1, c : "1" } but not viceversa
-    ASSERT_TRUE(shardKeyPatternHashed2_0.isExtendedBy(shardKeyPatternHashed3_0));
-    ASSERT_FALSE(shardKeyPatternHashed3_0.isExtendedBy(shardKeyPatternHashed2_0));
-
-    // { a : 1, b : "hashed " } is extended by { a : 1, b : "hashed", c : "1" } but not viceversa
-    ASSERT_TRUE(shardKeyPatternHashed2_1.isExtendedBy(shardKeyPatternHashed3_1));
-    ASSERT_FALSE(shardKeyPatternHashed3_1.isExtendedBy(shardKeyPatternHashed2_1));
-}
-
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/s/shard_util.cpp b/src/mongo/s/shard_util.cpp
index 62ee76524ea..ae5e1aa9a1b 100644
--- a/src/mongo/s/shard_util.cpp
+++ b/src/mongo/s/shard_util.cpp
@@ -132,8 +132,7 @@ StatusWith<std::vector<BSONObj>> selectChunkSplitPoints(OperationContext* opCtx,
                                                         const NamespaceString& nss,
                                                         const ShardKeyPattern& shardKeyPattern,
                                                         const ChunkRange& chunkRange,
-                                                        long long chunkSizeBytes,
-                                                        boost::optional<int> limit) {
+                                                        long long chunkSizeBytes) {
     auto shardStatus = Grid::get(opCtx)->shardRegistry()->getShard(opCtx, shardId);
     if (!shardStatus.isOK()) {
         return shardStatus.getStatus();
@@ -148,9 +147,8 @@ StatusWith<std::vector<BSONObj>> selectChunkSplitPoints(OperationContext* opCtx,
             Shard::RetryPolicy::kIdempotent);
     };
 
-    AutoSplitVectorRequest req(
+    const AutoSplitVectorRequest req(
         nss, shardKeyPattern.toBSON(), chunkRange.getMin(), chunkRange.getMax(), chunkSizeBytes);
-    req.setLimit(limit);
 
     auto cmdStatus = invokeSplitCommand(req.toBSON({}), nss.db());
 
diff --git a/src/mongo/s/shard_util.h b/src/mongo/s/shard_util.h
index 18eb780eb1e..997dcc1e4c9 100644
--- a/src/mongo/s/shard_util.h
+++ b/src/mongo/s/shard_util.h
@@ -79,20 +79,20 @@ StatusWith<long long> retrieveCollectionShardSize(OperationContext* opCtx,
 /**
  * Ask the specified shard to figure out the split points for a given chunk.
  *
- * - shardId: the shard id to query.
- * - nss: namespace, which owns the chunk.
- * - shardKeyPattern: the shard key which corresponds to this sharded namespace.
- * - chunkRange: bounds of the chunk to search for split points on.
- * - chunkSizeBytes: chunk size to target in bytes.
- * - limit: limits the number of split points to search. Unspecified means no limit
+ * shardId The shard id to query.
+ * nss Namespace, which owns the chunk.
+ * shardKeyPattern The shard key which corresponds to this sharded namespace.
+ * chunkRange Bounds of the chunk to be split.
+ * chunkSize Chunk size to target in bytes.
+ * maxObjs Limits the number of objects in each chunk. Zero means max, unspecified means use the
+ *         server default.
  */
 StatusWith<std::vector<BSONObj>> selectChunkSplitPoints(OperationContext* opCtx,
                                                         const ShardId& shardId,
                                                         const NamespaceString& nss,
                                                         const ShardKeyPattern& shardKeyPattern,
                                                         const ChunkRange& chunkRange,
-                                                        long long chunkSizeBytes,
-                                                        boost::optional<int> limit = boost::none);
+                                                        long long chunkSizeBytes);
 
 /**
  * Asks the specified shard to split the chunk described by min/maxKey into the respective split
diff --git a/src/mongo/s/sharding_feature_flags.idl b/src/mongo/s/sharding_feature_flags.idl
index aaeb4365106..2eea856a286 100644
--- a/src/mongo/s/sharding_feature_flags.idl
+++ b/src/mongo/s/sharding_feature_flags.idl
@@ -35,13 +35,11 @@ feature_flags:
   featureFlagNoMoreAutoSplitter:
     description: "Guarding code for the no more auto-splitter project"
     cpp_varname: feature_flags::gNoMoreAutoSplitter
-    default: true
-    version: 6.0
+    default: false
   featureFlagBalanceAccordingToDataSize:
     description: Balancer taking decisions based on the data size if enabled, based on number of chunks if disabled
     cpp_varname: feature_flags::gBalanceAccordingToDataSize
-    default: true
-    version: 6.0
+    default: false
   featureFlagShardingDataTransformMetrics:
       description: Feature flag for enabling the new metrics for global indexes and resharding.
       cpp_varname: feature_flags::gFeatureFlagShardingDataTransformMetrics
@@ -57,8 +55,3 @@ feature_flags:
     cpp_varname: feature_flags::gOrphanTracking
     default: true
     version: 6.0
-  featureFlagConcurrencyInChunkMigration:
-    description: "Feature flag for enabling concurrency within a chunk migration"
-    cpp_varname: feature_flags::gConcurrencyInChunkMigration
-    default: true
-    version: 6.0
diff --git a/src/mongo/s/sharding_initialization.cpp b/src/mongo/s/sharding_initialization.cpp
index aa183dd6177..98129648e05 100644
--- a/src/mongo/s/sharding_initialization.cpp
+++ b/src/mongo/s/sharding_initialization.cpp
@@ -196,7 +196,6 @@ Status initializeGlobalShardingState(OperationContext* opCtx,
     // The shard registry must be started once the grid is initialized
     grid->shardRegistry()->startupPeriodicReloader(opCtx);
 
-    // Start up the cluster time keys manager with a sharded keys client.
     auto keysCollectionClient =
         std::make_unique<KeysCollectionClientSharded>(grid->catalogClient());
     auto keyManager =
diff --git a/src/mongo/s/sharding_router_test_fixture.cpp b/src/mongo/s/sharding_router_test_fixture.cpp
index 2a5b2bfb8a4..4e9779773ac 100644
--- a/src/mongo/s/sharding_router_test_fixture.cpp
+++ b/src/mongo/s/sharding_router_test_fixture.cpp
@@ -70,7 +70,6 @@
 #include "mongo/s/write_ops/batched_command_response.h"
 #include "mongo/transport/mock_session.h"
 #include "mongo/transport/transport_layer_mock.h"
-#include "mongo/unittest/assert_that.h"
 #include "mongo/util/clock_source_mock.h"
 #include "mongo/util/tick_source_mock.h"
 
@@ -393,9 +392,7 @@ void ShardingTestFixture::checkReadConcern(const BSONObj& cmdObj,
     ASSERT_EQ(Object, readConcernElem.type());
 
     auto readConcernObj = readConcernElem.Obj();
-    using namespace unittest::match;
-    ASSERT_THAT(readConcernObj[repl::ReadConcernArgs::kLevelFieldName].str(),
-                AnyOf(Eq("majority"), Eq("snapshot")));
+    ASSERT_EQ("majority", readConcernObj[repl::ReadConcernArgs::kLevelFieldName].str());
 
     auto afterOpTimeElem = readConcernObj[repl::ReadConcernArgs::kAfterOpTimeFieldName];
     auto afterClusterTimeElem = readConcernObj[repl::ReadConcernArgs::kAfterClusterTimeFieldName];
diff --git a/src/mongo/s/sharding_task_executor_pool_controller.cpp b/src/mongo/s/sharding_task_executor_pool_controller.cpp
index c73967e6c50..d95a76a168f 100644
--- a/src/mongo/s/sharding_task_executor_pool_controller.cpp
+++ b/src/mongo/s/sharding_task_executor_pool_controller.cpp
@@ -253,7 +253,7 @@ auto ShardingTaskExecutorPoolController::updateHost(PoolId id, const HostState&
                 "maxConns"_attr = maxConns);
 
     // Update the target for just the pool first
-    poolData.target = stats.requests + stats.active + stats.leased;
+    poolData.target = stats.requests + stats.active;
 
     if (poolData.target < minConns) {
         poolData.target = minConns;
diff --git a/src/mongo/s/stale_exception.cpp b/src/mongo/s/stale_exception.cpp
index a04c6c27937..ac026a45ea2 100644
--- a/src/mongo/s/stale_exception.cpp
+++ b/src/mongo/s/stale_exception.cpp
@@ -39,18 +39,6 @@ MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(StaleConfigInfo);
 MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(StaleEpochInfo);
 MONGO_INIT_REGISTER_ERROR_EXTRA_INFO(StaleDbRoutingVersion);
 
-boost::optional<ChunkVersion> extractOptionalChunkVersion(const BSONObj& obj, StringData field) {
-    try {
-        return ChunkVersion::fromBSONLegacyOrNewerFormat(obj, field);
-    } catch (const DBException& ex) {
-        auto status = ex.toStatus();
-        if (status != ErrorCodes::NoSuchKey) {
-            throw;
-        }
-    }
-    return boost::none;
-}
-
 }  // namespace
 
 void StaleConfigInfo::serialize(BSONObjBuilder* bob) const {
@@ -68,35 +56,31 @@ std::shared_ptr<const ErrorExtraInfo> StaleConfigInfo::parse(const BSONObj& obj)
     const auto shardId = obj["shardId"].String();
     uassert(ErrorCodes::NoSuchKey, "The shardId field is missing", !shardId.empty());
 
+    auto extractOptionalChunkVersion = [&obj](StringData field) -> boost::optional<ChunkVersion> {
+        try {
+            return ChunkVersion::fromBSONLegacyOrNewerFormat(obj, field);
+        } catch (const DBException& ex) {
+            auto status = ex.toStatus();
+            if (status != ErrorCodes::NoSuchKey) {
+                throw;
+            }
+        }
+        return boost::none;
+    };
+
     return std::make_shared<StaleConfigInfo>(
         NamespaceString(obj["ns"].String()),
         ChunkVersion::fromBSONLegacyOrNewerFormat(obj, "vReceived"),
-        extractOptionalChunkVersion(obj, "vWanted"),
+        extractOptionalChunkVersion("vWanted"),
         ShardId(shardId));
 }
 
 void StaleEpochInfo::serialize(BSONObjBuilder* bob) const {
     bob->append("ns", _nss.ns());
-    if (_received)
-        _received->appendLegacyWithField(bob, "vReceived");
-    if (_wanted)
-        _wanted->appendLegacyWithField(bob, "vWanted");
 }
 
 std::shared_ptr<const ErrorExtraInfo> StaleEpochInfo::parse(const BSONObj& obj) {
-    auto received = extractOptionalChunkVersion(obj, "vReceived");
-    auto wanted = extractOptionalChunkVersion(obj, "vWanted");
-
-    uassert(6375907,
-            str::stream() << "Either both vReceived (" << received << ")"
-                          << " and vWanted (" << wanted << ") must be present or none",
-            received.is_initialized() == wanted.is_initialized());
-
-    if (received)
-        return std::make_shared<StaleEpochInfo>(
-            NamespaceString(obj["ns"].String()), *received, *wanted);
-    else
-        return std::make_shared<StaleEpochInfo>(NamespaceString(obj["ns"].String()));
+    return std::make_shared<StaleEpochInfo>(NamespaceString(obj["ns"].String()));
 }
 
 void StaleDbRoutingVersion::serialize(BSONObjBuilder* bob) const {
diff --git a/src/mongo/s/stale_exception.h b/src/mongo/s/stale_exception.h
index 1778fe689a4..d82b18bab52 100644
--- a/src/mongo/s/stale_exception.h
+++ b/src/mongo/s/stale_exception.h
@@ -75,7 +75,7 @@ public:
     void serialize(BSONObjBuilder* bob) const;
     static std::shared_ptr<const ErrorExtraInfo> parse(const BSONObj& obj);
 
-private:
+protected:
     NamespaceString _nss;
     ChunkVersion _received;
     boost::optional<ChunkVersion> _wanted;
@@ -85,42 +85,25 @@ private:
     boost::optional<SharedSemiFuture<void>> _criticalSectionSignal;
 };
 
-// TODO (SERVER-74380): Rename the StaleEpoch code to StaleDownstreamRouter and the info to
-// StaleDownstreamRouterInfo
 class StaleEpochInfo final : public ErrorExtraInfo {
 public:
     static constexpr auto code = ErrorCodes::StaleEpoch;
 
-    StaleEpochInfo(NamespaceString nss, ChunkVersion received, ChunkVersion wanted)
-        : _nss(std::move(nss)), _received(received), _wanted(wanted) {}
-
-    // TODO (SERVER-74380): Remove this constructor
     StaleEpochInfo(NamespaceString nss) : _nss(std::move(nss)) {}
 
     const auto& getNss() const {
         return _nss;
     }
 
-    const auto& getVersionReceived() const {
-        return _received;
-    }
-
-    const auto& getVersionWanted() const {
-        return _wanted;
-    }
-
     void serialize(BSONObjBuilder* bob) const;
     static std::shared_ptr<const ErrorExtraInfo> parse(const BSONObj& obj);
 
 private:
     NamespaceString _nss;
-
-    // TODO (SERVER-74380): These two fields are boost::optional for backwards compatibility. Either
-    // both of them are boost::none or both are set.
-    boost::optional<ChunkVersion> _received;
-    boost::optional<ChunkVersion> _wanted;
 };
 
+using StaleConfigException = ExceptionFor<ErrorCodes::StaleConfig>;
+
 class StaleDbRoutingVersion final : public ErrorExtraInfo {
 public:
     static constexpr auto code = ErrorCodes::StaleDbVersion;
diff --git a/src/mongo/s/stale_exception_test.cpp b/src/mongo/s/stale_exception_test.cpp
index 98a2b897af5..57cb2b89062 100644
--- a/src/mongo/s/stale_exception_test.cpp
+++ b/src/mongo/s/stale_exception_test.cpp
@@ -55,7 +55,7 @@ TEST(StaleExceptionTest, StaleConfigInfoSerializationTest) {
     ASSERT_EQUALS(deserializedInfo->getShardId(), kShardId);
 }
 
-TEST(StaleExceptionTest, StaleEpochInfoLegacySerializationTest) {
+TEST(StaleExceptionTest, StaleEpochInfoSerializationTest) {
     StaleEpochInfo info(kNss);
 
     // Serialize
@@ -67,24 +67,6 @@ TEST(StaleExceptionTest, StaleEpochInfoLegacySerializationTest) {
         std::static_pointer_cast<const StaleEpochInfo>(StaleEpochInfo::parse(bob.obj()));
 
     ASSERT_EQUALS(deserializedInfo->getNss(), kNss);
-    ASSERT(!deserializedInfo->getVersionReceived());
-    ASSERT(!deserializedInfo->getVersionWanted());
-}
-
-TEST(StaleExceptionTest, StaleEpochInfoSerializationTest) {
-    StaleEpochInfo info(kNss, ChunkVersion::UNSHARDED(), ChunkVersion::UNSHARDED());
-
-    // Serialize
-    BSONObjBuilder bob;
-    info.serialize(&bob);
-
-    // Deserialize
-    auto deserializedInfo =
-        std::static_pointer_cast<const StaleEpochInfo>(StaleEpochInfo::parse(bob.obj()));
-
-    ASSERT_EQ(deserializedInfo->getNss(), kNss);
-    ASSERT_EQ(*deserializedInfo->getVersionReceived(), ChunkVersion::UNSHARDED());
-    ASSERT_EQ(*deserializedInfo->getVersionWanted(), ChunkVersion::UNSHARDED());
 }
 
 }  // namespace
diff --git a/src/mongo/s/stale_shard_version_helpers.cpp b/src/mongo/s/stale_shard_version_helpers.cpp
index 07f5711cf6c..50e63c1667e 100644
--- a/src/mongo/s/stale_shard_version_helpers.cpp
+++ b/src/mongo/s/stale_shard_version_helpers.cpp
@@ -62,6 +62,10 @@ void checkErrorStatusAndMaxRetries(const Status& status,
     if (status == ErrorCodes::StaleDbVersion) {
         auto staleInfo = status.extraInfo<
             error_details::ErrorExtraInfoForImpl<ErrorCodes::StaleDbVersion>::type>();
+        invariant(staleInfo->getDb() == nss.db(),
+                  str::stream() << "StaleDbVersion error on unexpected database. Expected "
+                                << nss.db() << ", received " << staleInfo->getDb());
+
         // If the database version is stale, refresh its entry in the catalog cache.
         catalogCache->onStaleDatabaseVersion(staleInfo->getDb(), staleInfo->getVersionWanted());
 
@@ -74,6 +78,9 @@ void checkErrorStatusAndMaxRetries(const Status& status,
         // If the cache currently considers the collection to be unsharded, this will trigger an
         // epoch refresh. If no shard is provided, then the epoch is stale and we must refresh.
         if (auto staleInfo = status.extraInfo<StaleConfigInfo>()) {
+            invariant(staleInfo->getNss() == nss,
+                      str::stream() << "StaleConfig error on unexpected namespace. Expected " << nss
+                                    << ", received " << staleInfo->getNss());
             catalogCache->invalidateShardOrEntireCollectionEntryForShardedCollection(
                 nss, staleInfo->getVersionWanted(), staleInfo->getShardId());
         } else {
diff --git a/src/mongo/s/transaction_router.cpp b/src/mongo/s/transaction_router.cpp
index 01e9abefb86..db0cc68ca61 100644
--- a/src/mongo/s/transaction_router.cpp
+++ b/src/mongo/s/transaction_router.cpp
@@ -43,7 +43,6 @@
 #include "mongo/db/internal_transactions_feature_flag_gen.h"
 #include "mongo/db/jsobj.h"
 #include "mongo/db/logical_session_id.h"
-#include "mongo/db/namespace_string.h"
 #include "mongo/db/repl/read_concern_args.h"
 #include "mongo/db/transaction_validation.h"
 #include "mongo/db/txn_retry_counter_too_old_info.h"
@@ -71,11 +70,6 @@ using namespace fmt::literals;
 // TODO SERVER-39704: Remove this fail point once the router can safely retry within a transaction
 // on stale version and snapshot errors.
 MONGO_FAIL_POINT_DEFINE(enableStaleVersionAndSnapshotRetriesWithinTransactions);
-// This failpoint is used to skip the conflictPlacementTimestamp check for unittests in
-// transaction_router_test.cpp. The check involves fetching of the catalog cache, which the existing
-// unittests are not set up to do.
-MONGO_FAIL_POINT_DEFINE(skipConflictPlacementTimestampCheck);
-
 
 const char kCoordinatorField[] = "coordinator";
 const char kReadConcernLevelSnapshotName[] = "snapshot";
@@ -265,34 +259,6 @@ std::string actionTypeToString(TransactionRouter::TransactionActions action) {
     MONGO_UNREACHABLE;
 }
 
-/**
- * Sets the given logical time as the atClusterTime for the transaction to be the greater of
- * the given time and the user's afterClusterTime, if one was provided.
- */
-void setAtClusterTime(const LogicalSessionId& lsid,
-                      const TxnNumberAndRetryCounter& txnNumberAndRetryCounter,
-                      StmtId latestStmtId,
-                      TransactionRouter::AtClusterTime* atClusterTime,
-                      const boost::optional<LogicalTime>& afterClusterTime,
-                      const LogicalTime& candidateTime) {
-    // If the user passed afterClusterTime, the chosen time must be greater than or equal to it.
-    if (afterClusterTime && *afterClusterTime > candidateTime) {
-        atClusterTime->setTime(*afterClusterTime, latestStmtId);
-        return;
-    }
-
-    LOGV2_DEBUG(22888,
-                2,
-                "Setting global snapshot timestamp for transaction",
-                "sessionId"_attr = lsid,
-                "txnNumber"_attr = txnNumberAndRetryCounter.getTxnNumber(),
-                "txnRetryCounter"_attr = txnNumberAndRetryCounter.getTxnRetryCounter(),
-                "globalSnapshotTimestamp"_attr = candidateTime,
-                "latestStmtId"_attr = latestStmtId);
-
-    atClusterTime->setTime(candidateTime, latestStmtId);
-}
-
 }  // unnamed namespace
 
 TransactionRouter::TransactionRouter() = default;
@@ -384,8 +350,7 @@ void TransactionRouter::Observer::_reportTransactionState(OperationContext* opCt
     }
 
     if (_atClusterTimeHasBeenSet()) {
-        builder->append("globalReadTimestamp",
-                        o().atClusterTimeForSnapshotReadConcern->getTime().asTimestamp());
+        builder->append("globalReadTimestamp", o().atClusterTime->getTime().asTimestamp());
     }
 
     const auto& timingStats = o().metricsTracker->getTimingStats();
@@ -443,8 +408,7 @@ void TransactionRouter::Observer::_reportTransactionState(OperationContext* opCt
 }
 
 bool TransactionRouter::Observer::_atClusterTimeHasBeenSet() const {
-    return o().atClusterTimeForSnapshotReadConcern &&
-        o().atClusterTimeForSnapshotReadConcern->timeHasBeenSet();
+    return o().atClusterTime.is_initialized() && o().atClusterTime->timeHasBeenSet();
 }
 
 const LogicalSessionId& TransactionRouter::Observer::_sessionId() const {
@@ -491,7 +455,7 @@ BSONObj TransactionRouter::Participant::attachTxnFieldsIfNeeded(
     BSONObjBuilder newCmd = mustStartTransaction
         ? appendFieldsForStartTransaction(std::move(cmd),
                                           sharedOptions.readConcernArgs,
-                                          sharedOptions.atClusterTimeForSnapshotReadConcern,
+                                          sharedOptions.atClusterTime,
                                           !hasStartTxn)
         : BSONObjBuilder(std::move(cmd));
 
@@ -625,17 +589,12 @@ bool TransactionRouter::AtClusterTime::canChange(StmtId currentStmtId) const {
 }
 
 bool TransactionRouter::Router::mustUseAtClusterTime() const {
-    return o().atClusterTimeForSnapshotReadConcern.is_initialized();
+    return o().atClusterTime.is_initialized();
 }
 
 LogicalTime TransactionRouter::Router::getSelectedAtClusterTime() const {
-    invariant(o().atClusterTimeForSnapshotReadConcern);
-    return o().atClusterTimeForSnapshotReadConcern->getTime();
-}
-
-LogicalTime TransactionRouter::Router::getPlacementConflictTime() const {
-    invariant(o().placementConflictTimeForNonSnapshotReadConcern);
-    return o().placementConflictTimeForNonSnapshotReadConcern->getTime();
+    invariant(o().atClusterTime);
+    return o().atClusterTime->getTime();
 }
 
 const boost::optional<ShardId>& TransactionRouter::Router::getCoordinatorId() const {
@@ -646,76 +605,21 @@ const boost::optional<ShardId>& TransactionRouter::Router::getRecoveryShardId()
     return p().recoveryShardId;
 }
 
-void TransactionRouter::Router::_checkForPlacementConflict(OperationContext* opCtx,
-                                                           const ShardId& shardId,
-                                                           const NamespaceString& nss) {
-    // Check if the current routing table is aware of a data placement change that
-    // is more recent than the timestamp the current transaction started with. If
-    // so, we throw a MigrationConflict error to force the client to retry so the
-    // storage engine uses an up to date snapshot.
-    // No need to check it when using snapshot readConcern.
-    const auto cm =
-        uassertStatusOK(Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfo(opCtx, nss));
-    if (!_atClusterTimeHasBeenSet() && cm.isSharded() &&
-        (getPlacementConflictTime().asTimestamp() < cm.getMaxValidAfter(shardId))) {
-        uasserted(ErrorCodes::MigrationConflict,
-                  str::stream() << "Collection " << nss
-                                << " has undergone a catalog change operation at time "
-                                << cm.getMaxValidAfter(shardId)
-                                << " and no longer satisfies the "
-                                   "requirements for the current transaction which requires "
-                                << getPlacementConflictTime().asTimestamp()
-                                << ". Transaction will be aborted.");
-    }
-
-    // For dbVersion, the router needs to check when using both snapshot and non-snapshot read
-    // concerns.
-    if (!cm.isSharded()) {
-        const auto txnConflictTimestamp = _atClusterTimeHasBeenSet()
-            ? getSelectedAtClusterTime().asTimestamp()
-            : getPlacementConflictTime().asTimestamp();
-
-        bool dbWasCreatedByThisTransaction =
-            !p().createdDatabases.empty() && p().createdDatabases.count(nss.db().toString()) > 0;
-        if (txnConflictTimestamp < cm.dbVersion().getTimestamp() &&
-            !dbWasCreatedByThisTransaction) {
-            uasserted(ErrorCodes::MigrationConflict,
-                      str::stream() << "Database " << nss.db()
-                                    << " has undergone a catalog change operation at time "
-                                    << cm.dbVersion().getTimestamp()
-                                    << " and no longer satisfies the "
-                                       "requirements for the current transaction which requires "
-                                    << txnConflictTimestamp << ". Transaction will be aborted.");
-        }
-    }
-}
-
 BSONObj TransactionRouter::Router::attachTxnFieldsIfNeeded(OperationContext* opCtx,
                                                            const ShardId& shardId,
-                                                           const BSONObj& cmdObj,
-                                                           const StringData& dbName) {
-    // Skip the placement check if we are not running a transaction.
-    if (!(opCtx->isRetryableWrite() ||
-          MONGO_unlikely(skipConflictPlacementTimestampCheck.shouldFail()))) {
-        // For commands only against a db and not a collection, skip the placementConflict check.
-        if (auto nss = NamespaceString(CommandHelpers::parseNsFromCommand(dbName, cmdObj));
-            nsIsFull(nss.toString())) {
-            _checkForPlacementConflict(opCtx, shardId, nss);
-        }
-    }
-
+                                                           const BSONObj& cmdObj) {
     RouterTransactionsMetrics::get(opCtx)->incrementTotalRequestsTargeted();
     if (auto txnPart = getParticipant(shardId)) {
-        LOGV2_DEBUG(22883,
-                    4,
-                    "{sessionId}:{txnNumber} Sending transaction fields to existing "
-                    "participant: {shardId}",
-                    "Attaching transaction fields to request for existing participant shard",
-                    "sessionId"_attr = _sessionId(),
-                    "txnNumber"_attr = o().txnNumberAndRetryCounter.getTxnNumber(),
-                    "txnRetryCounter"_attr = o().txnNumberAndRetryCounter.getTxnRetryCounter(),
-                    "shardId"_attr = shardId,
-                    "request"_attr = redact(cmdObj));
+        LOGV2_DEBUG(
+            22883,
+            4,
+            "{sessionId}:{txnNumber} Sending transaction fields to existing participant: {shardId}",
+            "Attaching transaction fields to request for existing participant shard",
+            "sessionId"_attr = _sessionId(),
+            "txnNumber"_attr = o().txnNumberAndRetryCounter.getTxnNumber(),
+            "txnRetryCounter"_attr = o().txnNumberAndRetryCounter.getTxnRetryCounter(),
+            "shardId"_attr = shardId,
+            "request"_attr = redact(cmdObj));
         return txnPart->attachTxnFieldsIfNeeded(cmdObj, false);
     }
 
@@ -730,8 +634,7 @@ BSONObj TransactionRouter::Router::attachTxnFieldsIfNeeded(OperationContext* opC
                 "shardId"_attr = shardId,
                 "request"_attr = redact(cmdObj));
     if (!p().isRecoveringCommit) {
-        // Don't update participant stats during recovery since the participant list isn't
-        // known.
+        // Don't update participant stats during recovery since the participant list isn't known.
         RouterTransactionsMetrics::get(opCtx)->incrementTotalContactedParticipants();
     }
 
@@ -739,10 +642,9 @@ BSONObj TransactionRouter::Router::attachTxnFieldsIfNeeded(OperationContext* opC
 }
 
 void TransactionRouter::Router::_verifyParticipantAtClusterTime(const Participant& participant) {
-    const auto& participantAtClusterTime =
-        participant.sharedOptions.atClusterTimeForSnapshotReadConcern;
+    const auto& participantAtClusterTime = participant.sharedOptions.atClusterTime;
     invariant(participantAtClusterTime);
-    invariant(*participantAtClusterTime == o().atClusterTimeForSnapshotReadConcern->getTime());
+    invariant(*participantAtClusterTime == o().atClusterTime->getTime());
 }
 
 const TransactionRouter::Participant* TransactionRouter::Router::getParticipant(
@@ -751,7 +653,7 @@ const TransactionRouter::Participant* TransactionRouter::Router::getParticipant(
     if (iter == o().participants.end())
         return nullptr;
 
-    if (o().atClusterTimeForSnapshotReadConcern) {
+    if (o().atClusterTime) {
         _verifyParticipantAtClusterTime(iter->second);
     }
 
@@ -773,10 +675,8 @@ TransactionRouter::Participant& TransactionRouter::Router::_createParticipant(
         o().txnNumberAndRetryCounter,
         o().apiParameters,
         o().readConcernArgs,
-        o().atClusterTimeForSnapshotReadConcern
-            ? boost::optional<LogicalTime>(o().atClusterTimeForSnapshotReadConcern->getTime())
-            : boost::none,
-        boost::none,
+        o().atClusterTime ? boost::optional<LogicalTime>(o().atClusterTime->getTime())
+                          : boost::none,
         isInternalSessionForRetryableWrite(_sessionId())};
 
     stdx::lock_guard<Client> lk(*opCtx->getClient());
@@ -963,8 +863,7 @@ void TransactionRouter::Router::onViewResolutionError(OperationContext* opCtx,
 
 bool TransactionRouter::Router::canContinueOnSnapshotError() const {
     if (MONGO_unlikely(enableStaleVersionAndSnapshotRetriesWithinTransactions.shouldFail())) {
-        return o().atClusterTimeForSnapshotReadConcern &&
-            o().atClusterTimeForSnapshotReadConcern->canChange(p().latestStmtId);
+        return o().atClusterTime && o().atClusterTime->canChange(p().latestStmtId);
     }
 
     return false;
@@ -985,8 +884,7 @@ void TransactionRouter::Router::onSnapshotError(OperationContext* opCtx, const S
         "txnNumber"_attr = o().txnNumberAndRetryCounter.getTxnNumber(),
         "txnRetryCounter"_attr = o().txnNumberAndRetryCounter.getTxnRetryCounter(),
         "error"_attr = redact(status),
-        "previousGlobalSnapshotTimestamp"_attr =
-            o().atClusterTimeForSnapshotReadConcern->getTime());
+        "previousGlobalSnapshotTimestamp"_attr = o().atClusterTime->getTime());
 
     // The transaction must be restarted on all participants because a new read timestamp will be
     // selected, so clear all pending participants. Snapshot errors are only retryable on the first
@@ -998,37 +896,45 @@ void TransactionRouter::Router::onSnapshotError(OperationContext* opCtx, const S
     stdx::lock_guard<Client> lk(*opCtx->getClient());
 
     // Reset the global snapshot timestamp so the retry will select a new one.
-    o(lk).atClusterTimeForSnapshotReadConcern.reset();
-    o(lk).atClusterTimeForSnapshotReadConcern.emplace();
+    o(lk).atClusterTime.reset();
+    o(lk).atClusterTime.emplace();
 }
 
 void TransactionRouter::Router::setDefaultAtClusterTime(OperationContext* opCtx) {
+    if (!o().atClusterTime || !o().atClusterTime->canChange(p().latestStmtId)) {
+        return;
+    }
+
     const auto defaultTime = VectorClock::get(opCtx)->getTime();
+    _setAtClusterTime(opCtx,
+                      repl::ReadConcernArgs::get(opCtx).getArgsAfterClusterTime(),
+                      defaultTime.clusterTime());
+}
 
-    if (o().atClusterTimeForSnapshotReadConcern) {
-        if (o().atClusterTimeForSnapshotReadConcern->canChange(p().latestStmtId)) {
-            stdx::lock_guard<Client> lk(*opCtx->getClient());
-            setAtClusterTime(_sessionId(),
-                             o(lk).txnNumberAndRetryCounter,
-                             p().latestStmtId,
-                             o(lk).atClusterTimeForSnapshotReadConcern.get_ptr(),
-                             repl::ReadConcernArgs::get(opCtx).getArgsAfterClusterTime(),
-                             defaultTime.clusterTime());
-        }
-    } else if (o().placementConflictTimeForNonSnapshotReadConcern) {
-        // The placementConflictTimestamp is chosen to be the latest VectorClock time known, which
-        // should be regularly gossiped. This will ensure that we are not in a state where a mongos
-        // repeatedly chooses a stale timestamp and throw MigrationConflict errors.
-        if (o().placementConflictTimeForNonSnapshotReadConcern->canChange(p().latestStmtId)) {
-            stdx::lock_guard<Client> lk(*opCtx->getClient());
-            setAtClusterTime(_sessionId(),
-                             o(lk).txnNumberAndRetryCounter,
-                             p().latestStmtId,
-                             o(lk).placementConflictTimeForNonSnapshotReadConcern.get_ptr(),
-                             repl::ReadConcernArgs::get(opCtx).getArgsAfterClusterTime(),
-                             defaultTime.clusterTime());
-        }
+void TransactionRouter::Router::_setAtClusterTime(
+    OperationContext* opCtx,
+    const boost::optional<LogicalTime>& afterClusterTime,
+    LogicalTime candidateTime) {
+    stdx::lock_guard<Client> lk(*opCtx->getClient());
+
+    // If the user passed afterClusterTime, the chosen time must be greater than or equal to it.
+    if (afterClusterTime && *afterClusterTime > candidateTime) {
+        o(lk).atClusterTime->setTime(*afterClusterTime, p().latestStmtId);
+        return;
     }
+
+    LOGV2_DEBUG(22888,
+                2,
+                "{sessionId}:{txnNumber} Setting global snapshot timestamp to "
+                "{globalSnapshotTimestamp} on statement {latestStmtId}",
+                "Setting global snapshot timestamp for transaction",
+                "sessionId"_attr = _sessionId(),
+                "txnNumber"_attr = o().txnNumberAndRetryCounter.getTxnNumber(),
+                "txnRetryCounter"_attr = o().txnNumberAndRetryCounter.getTxnRetryCounter(),
+                "globalSnapshotTimestamp"_attr = candidateTime,
+                "latestStmtId"_attr = p().latestStmtId);
+
+    o(lk).atClusterTime->setTime(candidateTime, p().latestStmtId);
 }
 
 void TransactionRouter::Router::_continueTxn(OperationContext* opCtx,
@@ -1055,15 +961,6 @@ void TransactionRouter::Router::_continueTxn(OperationContext* opCtx,
             repl::ReadConcernArgs::get(opCtx) = o().readConcernArgs;
 
             ++p().latestStmtId;
-
-            uassert(
-                8027900,
-                str::stream() << "attempting to continue transaction that was not started lsid: "
-                              << _sessionId()
-                              << " txnNumber: " << o().txnNumberAndRetryCounter.getTxnNumber(),
-                o().atClusterTimeForSnapshotReadConcern ||
-                    o().placementConflictTimeForNonSnapshotReadConcern);
-
             _onContinue(opCtx);
             break;
         }
@@ -1554,12 +1451,10 @@ void TransactionRouter::Router::_resetRouterState(
         p().recoveryShardId.reset();
         o(lk).apiParameters = {};
         o(lk).readConcernArgs = {};
-        o(lk).atClusterTimeForSnapshotReadConcern.reset();
-        o(lk).placementConflictTimeForNonSnapshotReadConcern.reset();
+        o(lk).atClusterTime.reset();
         o(lk).abortCause = std::string();
         o(lk).metricsTracker.emplace(opCtx->getServiceContext());
         p().terminationInitiated = false;
-        p().createdDatabases.clear();
 
         auto tickSource = opCtx->getServiceContext()->getTickSource();
         o(lk).metricsTracker->trySetActive(tickSource, tickSource->getTicks());
@@ -1587,16 +1482,13 @@ void TransactionRouter::Router::_resetRouterStateForStartTransaction(
 
     {
         stdx::lock_guard<Client> lk(*opCtx->getClient());
-        auto& osw = o(lk);
-
-        osw.apiParameters = APIParameters::get(opCtx);
-        osw.readConcernArgs = readConcernArgs;
+        o(lk).apiParameters = APIParameters::get(opCtx);
+        o(lk).readConcernArgs = readConcernArgs;
+    }
 
-        if (osw.readConcernArgs.getLevel() == repl::ReadConcernLevel::kSnapshotReadConcern) {
-            osw.atClusterTimeForSnapshotReadConcern.emplace();
-        } else {
-            osw.placementConflictTimeForNonSnapshotReadConcern.emplace();
-        }
+    if (o().readConcernArgs.getLevel() == repl::ReadConcernLevel::kSnapshotReadConcern) {
+        stdx::lock_guard<Client> lk(*opCtx->getClient());
+        o(lk).atClusterTime.emplace();
     }
 
     LOGV2_DEBUG(22889,
@@ -1626,8 +1518,7 @@ BSONObj TransactionRouter::Router::_commitWithRecoveryToken(OperationContext* op
         auto rawCoordinateCommit = coordinateCommitCmd.toBSON(
             BSON(WriteConcernOptions::kWriteConcernField << opCtx->getWriteConcern().toBSON()));
 
-        return attachTxnFieldsIfNeeded(
-            opCtx, recoveryShardId, rawCoordinateCommit, coordinateCommitCmd.getDbName());
+        return attachTxnFieldsIfNeeded(opCtx, recoveryShardId, rawCoordinateCommit);
     }();
 
     auto recoveryShard = uassertStatusOK(shardRegistry->getShard(opCtx, recoveryShardId));
@@ -1664,7 +1555,7 @@ void TransactionRouter::Router::_logSlowTransaction(OperationContext* opCtx,
 
     std::string globalReadTimestampTemp;
     if (_atClusterTimeHasBeenSet()) {
-        globalReadTimestampTemp = o().atClusterTimeForSnapshotReadConcern->getTime().toString();
+        globalReadTimestampTemp = o().atClusterTime->getTime().toString();
         attrs.add("globalReadTimestamp", globalReadTimestampTemp);
     }
 
diff --git a/src/mongo/s/transaction_router.h b/src/mongo/s/transaction_router.h
index cf1be06dcca..a7b49c5eb12 100644
--- a/src/mongo/s/transaction_router.h
+++ b/src/mongo/s/transaction_router.h
@@ -90,9 +90,7 @@ public:
         repl::ReadConcernArgs readConcernArgs;
 
         // Only set for transactions with snapshot level read concern.
-        boost::optional<LogicalTime> atClusterTimeForSnapshotReadConcern;
-
-        boost::optional<LogicalTime> placementConflictTimeForNonSnapshotReadConcern;
+        boost::optional<LogicalTime> atClusterTime;
 
         bool isInternalTransactionForRetryableWrite;
     };
@@ -408,12 +406,11 @@ public:
          */
         BSONObj attachTxnFieldsIfNeeded(OperationContext* opCtx,
                                         const ShardId& shardId,
-                                        const BSONObj& cmdObj,
-                                        const StringData& dbName);
+                                        const BSONObj& cmdObj);
 
         /**
-         * Processes the transaction metadata in the response from the participant if the
-         * response indicates the operation succeeded.
+         * Processes the transaction metadata in the response from the participant if the response
+         * indicates the operation succeeded.
          */
         void processParticipantResponse(OperationContext* opCtx,
                                         const ShardId& shardId,
@@ -476,11 +473,6 @@ public:
         LogicalTime getSelectedAtClusterTime() const;
 
         /**
-         * Returns the placement conflict timestamp chosen for this transaction.
-         */
-        LogicalTime getPlacementConflictTime() const;
-
-        /**
          * Sets the atClusterTime for the current transaction to the latest time in the router's
          * logical clock. Does nothing if the transaction does not have snapshot read concern or an
          * atClusterTime has already been selected and cannot be changed.
@@ -565,13 +557,6 @@ public:
             return true;
         }
 
-        /**
-         * Annotate that this transaction has attempted to create database 'dbName'.
-         */
-        void annotateCreatedDatabase(const StringData dbName) {
-            p().createdDatabases.insert(dbName.toString());
-        }
-
     private:
         /**
          * Resets the router's state. Used when the router sees a new transaction for the first
@@ -624,6 +609,14 @@ public:
         BSONObj _handOffCommitToCoordinator(OperationContext* opCtx);
 
         /**
+         * Sets the given logical time as the atClusterTime for the transaction to be the greater of
+         * the given time and the user's afterClusterTime, if one was provided.
+         */
+        void _setAtClusterTime(OperationContext* opCtx,
+                               const boost::optional<LogicalTime>& afterClusterTime,
+                               LogicalTime candidateTime);
+
+        /**
          * Throws NoSuchTransaction if the response from abortTransaction failed with a code other
          * than NoSuchTransaction. Does not check for write concern errors.
          */
@@ -723,14 +716,6 @@ public:
          */
         bool _errorAllowsRetryOnStaleShardOrDb(const Status& status) const;
 
-        /**
-         * Check if the routing table has a higher timestamp than this transaction's
-         * placement conflict timestamp.
-         */
-        void _checkForPlacementConflict(OperationContext* opCtx,
-                                        const ShardId& shardId,
-                                        const NamespaceString& nss);
-
         TransactionRouter::PrivateState& p() {
             return _tr->_p;
         }
@@ -789,9 +774,7 @@ private:
         // The cluster time of the timestamp all participant shards in the current transaction with
         // snapshot level read concern must read from. Only set for transactions running with
         // snapshot level read concern.
-        boost::optional<AtClusterTime> atClusterTimeForSnapshotReadConcern;
-
-        boost::optional<AtClusterTime> placementConflictTimeForNonSnapshotReadConcern;
+        boost::optional<AtClusterTime> atClusterTime;
 
         // String representing the reason a transaction aborted. Either the string name of the error
         // code that led to an implicit abort or "abort" if the client sent abortTransaction.
@@ -840,9 +823,6 @@ private:
 
         // Track whether commit or abort have been initiated.
         bool terminationInitiated{false};
-
-        // Tracks databases that this transaction has attempted to create.
-        std::set<std::string> createdDatabases;
     } _p;
 };
 
diff --git a/src/mongo/s/transaction_router_test.cpp b/src/mongo/s/transaction_router_test.cpp
index d72d1aea6ff..1191e92d11e 100644
--- a/src/mongo/s/transaction_router_test.cpp
+++ b/src/mongo/s/transaction_router_test.cpp
@@ -137,8 +137,6 @@ protected:
 
         _staleVersionAndSnapshotRetriesBlock = std::make_unique<FailPointEnableBlock>(
             "enableStaleVersionAndSnapshotRetriesWithinTransactions");
-        _skipConflictPlacementTimestampCheck =
-            std::make_unique<FailPointEnableBlock>("skipConflictPlacementTimestampCheck");
     }
 
     void disableRouterRetriesFailPoint() {
@@ -220,10 +218,6 @@ protected:
         });
     }
 
-protected:
-    std::unique_ptr<FailPointEnableBlock> _skipConflictPlacementTimestampCheck;
-
-
 private:
     // Enables the transaction router to retry within a transaction on stale version and snapshot
     // errors for the duration of each test.
@@ -279,8 +273,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
     }
 
@@ -288,8 +281,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("update"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("update"
                                << "test"
                                << "coordinator" << true << "autocommit" << false << "txnNumber"
@@ -320,8 +312,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, BasicStartTxnWithAtClusterTime)
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
     }
 
@@ -329,8 +320,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, BasicStartTxnWithAtClusterTime)
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("update"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("update"
                                << "test"
                                << "coordinator" << true << "autocommit" << false << "txnNumber"
@@ -373,8 +363,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, NewParticipantMustAttachTxnAndRe
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
     }
 
@@ -382,8 +371,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, NewParticipantMustAttachTxnAndRe
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("update"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("update"
                                << "test"
                                << "coordinator" << true << "autocommit" << false << "txnNumber"
@@ -404,8 +392,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, NewParticipantMustAttachTxnAndRe
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard2,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
     }
 
@@ -413,8 +400,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, NewParticipantMustAttachTxnAndRe
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard2,
                                                         BSON("update"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("update"
                                << "test"
                                << "autocommit" << false << "txnNumber" << txnNum),
@@ -435,8 +421,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, StartingNewTxnShouldClearState)
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("update"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("update"
                                << "test"
                                << "readConcern"
@@ -467,8 +452,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, StartingNewTxnShouldClearState)
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
     }
 }
@@ -482,15 +466,14 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.beginOrContinueTxn(
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
 
     auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                     shard1,
                                                     BSON("insert"
                                                          << "test"
-                                                         << "txnNumber" << txnNum),
-                                                    "db");
+                                                         << "txnNumber" << txnNum));
     ASSERT_EQ(newCmd.hasField("txnRetryCounter"), false);
 }
 
@@ -506,7 +489,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, FirstParticipantIsCoordinator) {
     ASSERT_FALSE(txnRouter.getCoordinatorId());
 
     {
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         auto& participant = *txnRouter.getParticipant(shard1);
         ASSERT(participant.isCoordinator);
         ASSERT(txnRouter.getCoordinatorId());
@@ -514,7 +497,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, FirstParticipantIsCoordinator) {
     }
 
     {
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         auto& participant = *txnRouter.getParticipant(shard2);
         ASSERT(!participant.isCoordinator);
         ASSERT(txnRouter.getCoordinatorId());
@@ -530,7 +513,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, FirstParticipantIsCoordinator) {
     ASSERT_FALSE(txnRouter.getCoordinatorId());
 
     {
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         auto& participant = *txnRouter.getParticipant(shard2);
         ASSERT(participant.isCoordinator);
         ASSERT(txnRouter.getCoordinatorId());
@@ -551,7 +534,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardDoesNotGetSetForRea
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
     // The recovery shard is not set on scheduling requests.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
     // The recovery shard is not set if a participant responds with ok but that it is read-only.
@@ -559,7 +542,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardDoesNotGetSetForRea
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
     // The recovery shard is not set even if more read-only participants respond.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyTrueResponse);
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
@@ -590,7 +573,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard1);
@@ -606,7 +589,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     // Response to first statement says read-only.
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
@@ -629,12 +612,12 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says read-only.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
     ASSERT_FALSE(txnRouter.getRecoveryShardId());
 
     // Shard2's response says not read-only.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard2);
@@ -651,7 +634,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard1);
@@ -676,7 +659,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard1);
@@ -688,7 +671,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 
     // Shard2 responds, it doesn't matter whether it's read-only, just that it's a pending
     // participant.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard1);
@@ -713,7 +696,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, RecoveryShardIsResetOnStartingNe
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Shard1's response says not read-only.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT(txnRouter.getRecoveryShardId());
     ASSERT_EQ(*txnRouter.getRecoveryShardId(), shard1);
@@ -748,8 +731,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, DoesNotAttachTxnNumIfAlreadyTher
                                                     shard1,
                                                     BSON("insert"
                                                          << "test"
-                                                         << "txnNumber" << txnNum),
-                                                    "db");
+                                                         << "txnNumber" << txnNum));
     ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
 }
 
@@ -768,8 +750,7 @@ DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
                                       shard1,
                                       BSON("insert"
                                            << "test"
-                                           << "txnNumber" << TxnNumber(10)),
-                                      "db");
+                                           << "txnNumber" << TxnNumber(10)));
 }
 
 DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
@@ -831,8 +812,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, AttachTxnValidatesReadConcernIfA
                                                              << "test"
                                                              << "readConcern"
                                                              << BSON("level"
-                                                                     << "snapshot")),
-                                                        "db");
+                                                                     << "snapshot")));
         ASSERT_BSONOBJ_EQ(BSON("insert"
                                << "test"
                                << "readConcern"
@@ -943,8 +923,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, PassesThroughEmptyReadConcernToP
     auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                     shard1,
                                                     BSON("insert"
-                                                         << "test"),
-                                                    "db");
+                                                         << "test"));
     ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
 }
 
@@ -972,8 +951,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                     shard1,
                                                     BSON("insert"
-                                                         << "test"),
-                                                    "db");
+                                                         << "test"));
     ASSERT_BSONOBJ_EQ(expectedNewObj, newCmd);
 }
 
@@ -1098,7 +1076,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
 
     TxnRecoveryToken recoveryToken;
@@ -1135,7 +1113,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
 
     TxnRecoveryToken recoveryToken;
@@ -1172,8 +1150,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyTrueResponse);
 
@@ -1223,8 +1201,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -1272,8 +1250,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -1429,8 +1407,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
         txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -1489,8 +1467,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
             operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
         txnRouter.setDefaultAtClusterTime(operationContext());
 
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
         txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -1632,8 +1610,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsResetAtClusterTime
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
     }
 
@@ -1659,8 +1636,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsResetAtClusterTime
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
     }
 }
@@ -1683,8 +1659,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
     }
 
@@ -1704,8 +1679,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard2,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
     }
 
@@ -1725,8 +1699,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard3,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
     }
 }
@@ -1742,8 +1715,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsClearsAllParticipa
 
     // Successfully start a transaction on two shards, selecting one as the coordinator.
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     ASSERT(txnRouter.getCoordinatorId());
     ASSERT_EQ(*txnRouter.getCoordinatorId(), shard1);
@@ -1761,10 +1734,10 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsClearsAllParticipa
     ASSERT_FALSE(txnRouter.getCoordinatorId());
 
     {
-        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         ASSERT_TRUE(newCmd["startTransaction"].trueValue());
 
-        newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         ASSERT_FALSE(newCmd["startTransaction"].trueValue());
     }
 
@@ -1774,10 +1747,10 @@ TEST_F(TransactionRouterTestWithDefaultSession, SnapshotErrorsClearsAllParticipa
 
     {
         // Shard1 should also attach startTransaction field again.
-        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         ASSERT_TRUE(newCmd["startTransaction"].trueValue());
 
-        newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         ASSERT_FALSE(newCmd["startTransaction"].trueValue());
     }
 }
@@ -1819,8 +1792,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
     // command.
 
     int initialStmtId = 0;
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     ASSERT_EQ(txnRouter.getParticipant(shard1)->stmtIdCreatedAt, initialStmtId);
     ASSERT_EQ(txnRouter.getParticipant(shard2)->stmtIdCreatedAt, initialStmtId);
@@ -1830,7 +1803,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
         operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     ShardId shard3("shard3");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
     ASSERT_EQ(txnRouter.getParticipant(shard3)->stmtIdCreatedAt, initialStmtId + 1);
 
     ASSERT_EQ(txnRouter.getParticipant(shard1)->stmtIdCreatedAt, initialStmtId);
@@ -1847,8 +1820,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
         operationContext(), txnNum2, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     ASSERT_EQ(txnRouter.getParticipant(shard3)->stmtIdCreatedAt, initialStmtId);
     ASSERT_EQ(txnRouter.getParticipant(shard2)->stmtIdCreatedAt, initialStmtId);
@@ -1857,7 +1830,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, ParticipantsRememberStmtIdCreate
     txnRouter.beginOrContinueTxn(
         operationContext(), txnNum2, TransactionRouter::TransactionActions::kContinue);
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_EQ(txnRouter.getParticipant(shard1)->stmtIdCreatedAt, initialStmtId + 1);
 }
 
@@ -1874,8 +1847,8 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     // Start a transaction on two shards, selecting one as the coordinator, but simulate a
     // re-targeting error from at least one of them.
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     ASSERT(txnRouter.getCoordinatorId());
     ASSERT_EQ(*txnRouter.getCoordinatorId(), shard1);
@@ -1892,7 +1865,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
 
     {
         ASSERT_FALSE(txnRouter.getParticipant(shard2));
-        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         ASSERT_TRUE(newCmd["startTransaction"].trueValue());
     }
 
@@ -1903,7 +1876,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     {
         // Shard1 has not started a transaction.
         ASSERT_FALSE(txnRouter.getParticipant(shard1));
-        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         ASSERT_TRUE(newCmd["startTransaction"].trueValue());
     }
 }
@@ -1919,7 +1892,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnlyNewlyCreatedParticipantsClea
 
     // First statement successfully targets one shard, selecing it as the coordinator.
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     ASSERT(txnRouter.getCoordinatorId());
     ASSERT_EQ(*txnRouter.getCoordinatorId(), shard1);
@@ -1931,8 +1904,8 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnlyNewlyCreatedParticipantsClea
     txnRouter.beginOrContinueTxn(
         operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
 
     ASSERT(txnRouter.canContinueOnStaleShardOrDbError("find", kDummyStatus));
     auto future = launchAsync(
@@ -1942,13 +1915,13 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnlyNewlyCreatedParticipantsClea
 
     // Shards 2 and 3 must start a transaction, but shard 1 must not.
     ASSERT_FALSE(
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db")["startTransaction"]
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {})["startTransaction"]
             .trueValue());
     ASSERT_TRUE(
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db")["startTransaction"]
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {})["startTransaction"]
             .trueValue());
     ASSERT_TRUE(
-        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db")["startTransaction"]
+        txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {})["startTransaction"]
             .trueValue());
 }
 
@@ -1987,8 +1960,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                     shard1,
                                                     BSON("find"
-                                                         << "test"),
-                                                    "db");
+                                                         << "test"));
     ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
 
     auto future =
@@ -2001,8 +1973,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                shard1,
                                                BSON("find"
-                                                    << "test"),
-                                               "db");
+                                                    << "test"));
     ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
 }
 
@@ -2071,7 +2042,7 @@ TEST_F(TransactionRouterTest, AbortForSingleParticipant) {
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     auto future = launchAsync([&] { return txnRouter.abortTransaction(operationContext()); });
 
@@ -2104,8 +2075,8 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsAllReturnSuccess) {
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -2147,9 +2118,9 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNoSuchTransa
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard3, kOkReadOnlyFalseResponse);
@@ -2196,9 +2167,9 @@ TEST_F(TransactionRouterTest, AbortForMultipleParticipantsSomeReturnNetworkError
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard3, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     txnRouter.processParticipantResponse(operationContext(), shard3, kOkReadOnlyFalseResponse);
@@ -2246,7 +2217,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // One shard is targeted by the first statement.
-    auto firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    auto firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_TRUE(firstShardCmd["startTransaction"].trueValue());
 
     ASSERT(txnRouter.getCoordinatorId());
@@ -2264,7 +2235,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     ASSERT_FALSE(txnRouter.getCoordinatorId());
 
     // The first shard is targeted by the retry and should have to start a transaction again.
-    firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_TRUE(firstShardCmd["startTransaction"].trueValue());
 
     // Advance to a later client statement that targets a new shard.
@@ -2273,7 +2244,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     txnRouter.beginOrContinueTxn(
         operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
-    auto secondShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    auto secondShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     ASSERT_TRUE(secondShardCmd["startTransaction"].trueValue());
 
     // Simulate a view resolution error.
@@ -2283,9 +2254,9 @@ TEST_F(TransactionRouterTestWithDefaultSession, OnViewResolutionErrorClearsAllNe
     future.default_timed_get();
 
     // Only the new participant shard was reset.
-    firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    firstShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_FALSE(firstShardCmd["startTransaction"].trueValue());
-    secondShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    secondShardCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     ASSERT_TRUE(secondShardCmd["startTransaction"].trueValue());
 }
 
@@ -2319,7 +2290,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortForSingleParticipant) {
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     auto future = launchAsync(
         [&] { return txnRouter.implicitlyAbortTransaction(operationContext(), kDummyStatus); });
@@ -2352,8 +2323,8 @@ TEST_F(TransactionRouterTest, ImplicitAbortForMultipleParticipants) {
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     auto future = launchAsync(
         [&] { return txnRouter.implicitlyAbortTransaction(operationContext(), kDummyStatus); });
@@ -2393,7 +2364,7 @@ TEST_F(TransactionRouterTest, ImplicitAbortIgnoresErrors) {
 
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     auto future = launchAsync(
         [&] { return txnRouter.implicitlyAbortTransaction(operationContext(), kDummyStatus); });
@@ -2414,26 +2385,6 @@ TEST_F(TransactionRouterTest, ImplicitAbortIgnoresErrors) {
     future.default_timed_get();
 }
 
-TEST_F(TransactionRouterTest, CannotContinueAfterCommit) {
-    LogicalSessionId lsid(makeLogicalSessionIdForTest());
-    TxnNumber txnNum{3};
-
-    auto opCtx = operationContext();
-    opCtx->setLogicalSessionId(lsid);
-    opCtx->setTxnNumber(txnNum);
-
-    RouterOperationContextSession scopedSession(opCtx);
-    auto txnRouter = TransactionRouter::get(opCtx);
-
-    txnRouter.beginOrContinueTxn(
-        operationContext(), txnNum, TransactionRouter::TransactionActions::kCommit);
-    txnRouter.setDefaultAtClusterTime(operationContext());
-
-    ASSERT_THROWS(txnRouter.beginOrContinueTxn(
-                      opCtx, txnNum, TransactionRouter::TransactionActions::kContinue),
-                  AssertionException);
-}
-
 TEST_F(TransactionRouterTestWithDefaultSession, AbortPropagatesWriteConcern) {
     TxnNumber txnNum{3};
     operationContext()->setTxnNumber(txnNum);
@@ -2447,7 +2398,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, AbortPropagatesWriteConcern) {
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
-    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
 
     auto future = launchAsync([&] { return txnRouter.abortTransaction(operationContext()); });
 
@@ -2471,7 +2422,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinueOnlyOnStaleVersionOnFirs
     txnRouter.beginOrContinueTxn(
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     disableRouterRetriesFailPoint();
 
@@ -2486,10 +2437,10 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinueOnlyOnStaleVersionOnFirs
     txnRouter.onStaleShardOrDbError(operationContext(), "find", kStaleConfigStatus);
 
     // Readd the initial participant removed on onStaleShardOrDbError
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     // Add another participant
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     // Check that the transaction cannot continue on stale config with more than one participant
     ASSERT_FALSE(txnRouter.canContinueOnStaleShardOrDbError("update", kStaleConfigStatus));
@@ -2511,7 +2462,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, ContinueOnlyOnStaleVersionOnFirs
         operationContext(), txnNum, TransactionRouter::TransactionActions::kContinue);
 
     // Cannot retry on a stale config error with one participant after the first statement.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     ASSERT_FALSE(txnRouter.canContinueOnStaleShardOrDbError("update", kStaleConfigStatus));
 }
@@ -2558,8 +2509,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                     shard1,
                                                     BSON("insert"
-                                                         << "test"),
-                                                    "db");
+                                                         << "test"));
     ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
 
     // The next statement cannot change the atClusterTime.
@@ -2577,8 +2527,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                shard2,
                                                BSON("insert"
-                                                    << "test"),
-                                               "db");
+                                                    << "test"));
     ASSERT_BSONOBJ_EQ(expectedReadConcern, newCmd["readConcern"].Obj());
 }
 
@@ -2618,24 +2567,21 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(expectedRC, newCmd["readConcern"].Obj());
 
         // Only attached on first command to a participant.
         newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                    shard1,
                                                    BSON("insert"
-                                                        << "test"),
-                                                   "db");
+                                                        << "test"));
         ASSERT(newCmd["readConcern"].eoo());
 
         // Attached for new participants after the first one.
         newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                    shard2,
                                                    BSON("insert"
-                                                        << "test"),
-                                                   "db");
+                                                        << "test"));
         ASSERT_BSONOBJ_EQ(expectedRC, newCmd["readConcern"].Obj());
     }
 }
@@ -2656,8 +2602,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(
             BSON("level" << rcIt.first << "afterClusterTime" << clusterTime.asTimestamp()),
             newCmd["readConcern"].Obj());
@@ -2680,8 +2625,7 @@ TEST_F(TransactionRouterTestWithDefaultSession, NonSnapshotReadConcernLevelsPres
         auto newCmd = txnRouter.attachTxnFieldsIfNeeded(operationContext(),
                                                         shard1,
                                                         BSON("insert"
-                                                             << "test"),
-                                                        "db");
+                                                             << "test"));
         ASSERT_BSONOBJ_EQ(BSON("level" << rcIt.first << "afterOpTime" << opTime),
                           newCmd["readConcern"].Obj());
     }
@@ -2701,7 +2645,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     //
 
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     ASSERT(txnRouter.canContinueOnSnapshotError());
     auto future = launchAsync([&] { txnRouter.onSnapshotError(operationContext(), kDummyStatus); });
@@ -2732,7 +2676,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     //
 
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     ASSERT(txnRouter.canContinueOnSnapshotError());
     auto future = launchAsync([&] { txnRouter.onSnapshotError(operationContext(), kDummyStatus); });
@@ -2765,7 +2709,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     //
 
     txnRouter.setDefaultAtClusterTime(operationContext());
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     ASSERT(txnRouter.canContinueOnSnapshotError());
     auto future = launchAsync([&] {
@@ -2795,8 +2739,8 @@ DEATH_TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.setDefaultAtClusterTime(operationContext());
 
     // Add some participants to the list.
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     // Simulate response from some participant not in the list.
     txnRouter.processParticipantResponse(operationContext(), shard3, kOkReadOnlyTrueResponse);
@@ -2812,7 +2756,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, BSON("ok" << 0));
     ASSERT(TransactionRouter::Participant::ReadOnly::kUnset ==
            txnRouter.getParticipant(shard1)->readOnly);
@@ -2828,7 +2772,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
 
     const auto participant = txnRouter.getParticipant(shard1);
@@ -2854,7 +2798,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
 
     const auto participant = txnRouter.getParticipant(shard1);
@@ -2880,7 +2824,7 @@ TEST_F(
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     // First response says readOnly: true.
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
@@ -2907,7 +2851,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     // First response says readOnly: false.
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
@@ -2933,7 +2877,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
         operationContext(), txnNum, TransactionRouter::TransactionActions::kStart);
     txnRouter.setDefaultAtClusterTime(operationContext());
 
-    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(operationContext(), shard1, {});
 
     // First response is an error.
     txnRouter.processParticipantResponse(operationContext(), shard1, BSON("ok" << 0));
@@ -2971,7 +2915,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
-    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
 
     // Continue causes the _latestStmtId to be bumped.
     repl::ReadConcernArgs::get(opCtx) = repl::ReadConcernArgs();
@@ -2998,7 +2942,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
-    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
 
     // Aborting will set the termination initiation state.
     auto future = launchAsync([&] { txnRouter.implicitlyAbortTransaction(opCtx, kDummyStatus); });
@@ -3021,7 +2965,7 @@ TEST_F(TransactionRouterTestWithDefaultSession,
     txnRouter.beginOrContinueTxn(opCtx, txnNum, TransactionRouter::TransactionActions::kStart);
 
     txnRouter.setDefaultAtClusterTime(opCtx);
-    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {}, "db");
+    txnRouter.attachTxnFieldsIfNeeded(opCtx, shard1, {});
 
     // Process !readonly response to set participant state.
     txnRouter.processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
@@ -3145,92 +3089,6 @@ TEST_F(TransactionRouterTestWithDefaultSession, CannotBeReapedWithActiveYielders
     ASSERT(txnRouter.canBeReaped());
 }
 
-TEST_F(TransactionRouterTestWithDefaultSession, DetectsConflictsDueToMovePrimary) {
-    _skipConflictPlacementTimestampCheck.reset();
-
-    const auto kDbName = "testDB";
-    const auto kNss = NamespaceString(kDbName, "collA");
-
-    TxnNumber txnNum{3};
-
-    const auto runTest = [&]() {
-        const auto setCatalogCache = [&](Timestamp databaseTimestamp) {
-            auto refreshFuture = launchAsync([this, kNss] {
-                auto client = getServiceContext()->makeClient("Test");
-                auto const catalogCache = Grid::get(getServiceContext())->catalogCache();
-
-                uassertStatusOK(
-                    catalogCache->getDatabaseWithRefresh(operationContext(), kNss.db()));
-
-                return boost::make_optional(uassertStatusOK(
-                    catalogCache->getCollectionRoutingInfoWithRefresh(operationContext(), kNss)));
-            });
-
-            // Set kDbName with the requested database timestamp.
-            expectFindSendBSONObjVector(kTestConfigShardHost, [&]() {
-                DatabaseType db(kDbName, shard1, DatabaseVersion(UUID::gen(), databaseTimestamp));
-                return std::vector<BSONObj>{db.toBSON()};
-            }());
-
-            // Set kNss as an unsharded collection.
-            expectFindSendBSONObjVector(kTestConfigShardHost,
-                                        []() { return std::vector<BSONObj>{}; }());
-
-            refreshFuture.default_timed_get();
-        };
-
-        operationContext()->setTxnNumber(txnNum);
-        operationContext()->setInMultiDocumentTransaction();
-
-        auto txnRouter = TransactionRouter::get(operationContext());
-        txnRouter.beginOrContinueTxn(
-            operationContext(), txnNum++, TransactionRouter::TransactionActions::kStart);
-        txnRouter.setDefaultAtClusterTime(operationContext());
-
-        // Note the fixture sets VectorClock::clusterTime to Timestamp(3, 1). This will get used by
-        // the transaction as 'atClusterTime'/'placementConflictTime'.
-
-        // Database timestamp is valid for the transaction.
-        setCatalogCache(Timestamp(2, 0));
-
-        ASSERT_DOES_NOT_THROW(txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                                shard1,
-                                                                BSON("insert"
-                                                                     << "collA"),
-                                                                kDbName));
-
-        // Database timestamp is not valid for the transaction.
-        setCatalogCache(Timestamp(4, 0));
-
-        ASSERT_THROWS_CODE(txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                             shard1,
-                                                             BSON("insert"
-                                                                  << "collA"),
-                                                             kDbName),
-                           AssertionException,
-                           ErrorCodes::MigrationConflict);
-
-        // But no error if this transaction created that database.
-        txnRouter.annotateCreatedDatabase(kDbName);
-        ASSERT_DOES_NOT_THROW(txnRouter.attachTxnFieldsIfNeeded(operationContext(),
-                                                                shard1,
-                                                                BSON("insert"
-                                                                     << "collA"),
-                                                                kDbName));
-    };
-
-    // Test with non-snapshot read concern.
-    repl::ReadConcernArgs::get(operationContext()) =
-        repl::ReadConcernArgs(repl::ReadConcernLevel::kLocalReadConcern);
-    runTest();
-
-    // Test with snapshot read concern.
-    repl::ReadConcernArgs::get(operationContext()) =
-        repl::ReadConcernArgs(repl::ReadConcernLevel::kSnapshotReadConcern);
-    runTest();
-}
-
-
 // Begins a transaction with snapshot level read concern and sets a default cluster time.
 class TransactionRouterTestWithDefaultSessionAndStartedSnapshot
     : public TransactionRouterTestWithDefaultSession {
@@ -3259,8 +3117,7 @@ TEST_F(TransactionRouterTestWithDefaultSessionAndStartedSnapshot, AddAtClusterTi
                                                          << "testColl"
                                                          << "readConcern"
                                                          << BSON("level"
-                                                                 << "snapshot")),
-                                                    "db");
+                                                                 << "snapshot")));
 
     ASSERT_BSONOBJ_EQ(rcLatestInMemoryAtClusterTime, newCmd["readConcern"].Obj());
 }
@@ -3278,8 +3135,7 @@ TEST_F(TransactionRouterTestWithDefaultSessionAndStartedSnapshot,
                                                          << BSON("level"
                                                                  << "snapshot"
                                                                  << "afterClusterTime"
-                                                                 << existingAfterClusterTime)),
-                                                    "db");
+                                                                 << existingAfterClusterTime)));
 
     ASSERT_BSONOBJ_EQ(rcLatestInMemoryAtClusterTime, newCmd["readConcern"].Obj());
 }
@@ -3378,7 +3234,7 @@ protected:
     //
 
     void explicitAbortInProgress() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard1, kOkReadOnlyFalseResponse);
 
@@ -3390,7 +3246,7 @@ protected:
     }
 
     void implicitAbortInProgress() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard1, kOkReadOnlyFalseResponse);
 
@@ -3403,7 +3259,7 @@ protected:
     }
 
     void runCommit(StatusWith<BSONObj> swRes, bool expectRetries = false) {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard1, kOkReadOnlyFalseResponse);
 
@@ -3459,7 +3315,7 @@ protected:
     }
 
     void runSingleShardCommit() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
 
         startCapturingLogMessages();
@@ -3471,9 +3327,9 @@ protected:
     }
 
     void runReadOnlyCommit() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         txnRouter().processParticipantResponse(operationContext(), shard2, kOkReadOnlyTrueResponse);
 
         startCapturingLogMessages();
@@ -3486,9 +3342,9 @@ protected:
     }
 
     void runSingleWriteShardCommit() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyTrueResponse);
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -3501,10 +3357,10 @@ protected:
     }
 
     void runTwoPhaseCommit() {
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard1, kOkReadOnlyFalseResponse);
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard2, kOkReadOnlyFalseResponse);
 
@@ -3543,7 +3399,7 @@ protected:
 
     auto beginAndPauseCommit() {
         // Commit after targeting one shard so the commit has to do work and can be paused.
-        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+        txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
         txnRouter().processParticipantResponse(
             operationContext(), shard1, kOkReadOnlyFalseResponse);
         auto future = launchAsync(
@@ -4655,6 +4511,17 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_Stash) {
     ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentInactive());
 }
 
+TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_BeginAfterStash) {
+    beginRecoverCommitWithDefaultTxnNumber();
+    txnRouter().stash(operationContext(), TransactionRouter::StashReason::kDone);
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber, TransactionRouter::TransactionActions::kContinue);
+
+    ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentOpen());
+    ASSERT_EQUALS(1L, routerTxnMetrics()->getCurrentActive());
+    ASSERT_EQUALS(0L, routerTxnMetrics()->getCurrentInactive());
+}
+
 TEST_F(TransactionRouterMetricsTest, RouterMetricsCurrent_AreNotCumulative) {
     // Test active.
     beginTxnWithDefaultTxnNumber();
@@ -5072,14 +4939,14 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalContactedParticipants) {
     beginTxnWithDefaultTxnNumber();
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalContactedParticipants());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalContactedParticipants());
 
     // Only increases for new participants.
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalContactedParticipants());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalContactedParticipants());
 
     // Is cumulative across transactions.
@@ -5087,7 +4954,7 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalContactedParticipants) {
         operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalContactedParticipants());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     ASSERT_EQUALS(3L, routerTxnMetrics()->getTotalContactedParticipants());
 }
 
@@ -5100,15 +4967,15 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalRequestsTargeted) {
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalRequestsTargeted());
 
     // Increases each time transaction fields are attached.
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT_EQUALS(1L, routerTxnMetrics()->getTotalRequestsTargeted());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT_EQUALS(2L, routerTxnMetrics()->getTotalRequestsTargeted());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter().processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     ASSERT_EQUALS(3L, routerTxnMetrics()->getTotalRequestsTargeted());
 }
@@ -5148,11 +5015,11 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalParticipantsAtCommit) {
     beginTxnWithDefaultTxnNumber();
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalParticipantsAtCommit());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     txnRouter().processParticipantResponse(operationContext(), shard1, kOkReadOnlyFalseResponse);
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalParticipantsAtCommit());
 
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
     txnRouter().processParticipantResponse(operationContext(), shard2, kOkReadOnlyFalseResponse);
     ASSERT_EQUALS(0L, routerTxnMetrics()->getTotalParticipantsAtCommit());
 
@@ -5169,7 +5036,7 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsTotalParticipantsAtCommit) {
     operationContext()->setTxnNumber(kTxnNumber + 1);
     txnRouter().beginOrContinueTxn(
         operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
     runCommit(kDummyOkRes);
     ASSERT_EQUALS(3L, routerTxnMetrics()->getTotalParticipantsAtCommit());
 }
@@ -5333,8 +5200,8 @@ TEST_F(TransactionRouterMetricsTest, ReportResourcesWithParticipantList) {
     clockSource->reset(startTime);
 
     beginTxnWithDefaultTxnNumber();
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {}, "db");
-    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {}, "db");
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard1, {});
+    txnRouter().attachTxnFieldsIfNeeded(operationContext(), shard2, {});
 
     auto state = txnRouter().reportState(operationContext(), true /* sessionIsActive */);
     auto transactionDocument = state.getObjectField("transaction");
diff --git a/src/mongo/s/write_ops/batch_write_exec.cpp b/src/mongo/s/write_ops/batch_write_exec.cpp
index 980d376b607..45b89579dbb 100644
--- a/src/mongo/s/write_ops/batch_write_exec.cpp
+++ b/src/mongo/s/write_ops/batch_write_exec.cpp
@@ -104,25 +104,6 @@ bool hasTransientTransactionError(const BatchedCommandResponse& response) {
 // applies when no writes are occurring and metadata is not changing on reload.
 const int kMaxRoundsWithoutProgress(5);
 
-/**
- * Provides the write concern with which child batches have to be internally submitted.
- */
-boost::optional<WriteConcernOptions> getWriteConcernForChildBatch(OperationContext* opCtx) {
-    // Per-operation write concern is not supported in transactions.
-    if (TransactionRouter::get(opCtx)) {
-        return boost::none;
-    }
-
-    // Retrieve the WC specified by the remote client; in case of "fire and forget" request, the WC
-    // needs to be upgraded to "w: 1" for the sharding protocol to correctly handle internal
-    // writeErrors.
-    auto wc = opCtx->getWriteConcern();
-    if (!wc.requiresWriteAcknowledgement()) {
-        wc.w = 1;
-    }
-
-    return wc;
-}
 }  // namespace
 
 void BatchWriteExec::executeBatch(OperationContext* opCtx,
@@ -214,7 +195,6 @@ void BatchWriteExec::executeBatch(OperationContext* opCtx,
             //
 
             std::vector<AsyncRequestsSender::Request> requests;
-            const auto wcSettingForChildBatch = getWriteConcernForChildBatch(opCtx);
 
             // Get as many batches as we can at once
             for (auto&& childBatch : childBatches) {
@@ -237,10 +217,6 @@ void BatchWriteExec::executeBatch(OperationContext* opCtx,
                     BSONObjBuilder requestBuilder;
                     shardBatchRequest.serialize(&requestBuilder);
                     logical_session_id_helpers::serializeLsidAndTxnNumber(opCtx, &requestBuilder);
-                    if (wcSettingForChildBatch) {
-                        requestBuilder.append(WriteConcernOptions::kWriteConcernField,
-                                              wcSettingForChildBatch->toBSON());
-                    }
 
                     return requestBuilder.obj();
                 }();
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 3e90e5b65d3..3b4079b4c84 100644
--- a/src/mongo/s/write_ops/batch_write_exec_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_exec_test.cpp
@@ -33,14 +33,12 @@
 #include "mongo/client/remote_command_targeter_factory_mock.h"
 #include "mongo/client/remote_command_targeter_mock.h"
 #include "mongo/db/commands.h"
-#include "mongo/db/concurrency/write_conflict_exception.h"
 #include "mongo/db/logical_session_id.h"
 #include "mongo/db/vector_clock.h"
 #include "mongo/s/catalog/type_shard.h"
 #include "mongo/s/client/shard_registry.h"
 #include "mongo/s/mock_ns_targeter.h"
 #include "mongo/s/session_catalog_router.h"
-#include "mongo/s/shard_cannot_refresh_due_to_locks_held_exception.h"
 #include "mongo/s/sharding_router_test_fixture.h"
 #include "mongo/s/stale_exception.h"
 #include "mongo/s/transaction_router.h"
@@ -202,40 +200,6 @@ BSONObj expectInsertsReturnTenantMigrationAbortedErrorsBase(
     return tenantMigrationAbortedResponse.obj();
 }
 
-BSONObj expectInsertsReturnCannotRefreshErrorsBase(const NamespaceString& nss,
-                                                   const std::vector<BSONObj>& expected,
-                                                   const executor::RemoteCommandRequest& request) {
-    ASSERT_EQUALS(nss.db(), request.dbname);
-
-    const auto opMsgRequest(OpMsgRequest::fromDBAndBody(request.dbname, request.cmdObj));
-    const auto actualBatchedInsert(BatchedCommandRequest::parseInsert(opMsgRequest));
-    ASSERT_EQUALS(nss.toString(), actualBatchedInsert.getNS().ns());
-
-    const auto& inserted = actualBatchedInsert.getInsertRequest().getDocuments();
-    ASSERT_EQUALS(expected.size(), inserted.size());
-
-    auto itInserted = inserted.begin();
-    auto itExpected = expected.begin();
-
-    for (; itInserted != inserted.end(); itInserted++, itExpected++) {
-        ASSERT_BSONOBJ_EQ(*itExpected, *itInserted);
-    }
-
-    BatchedCommandResponse cannotRefreshResponse;
-    cannotRefreshResponse.setStatus(Status::OK());
-    cannotRefreshResponse.setN(0);
-
-    // Report a ShardCannotRefreshDueToLocksHeld error for each write in the batch.
-    int i = 0;
-    for (itInserted = inserted.begin(); itInserted != inserted.end(); ++itInserted) {
-        cannotRefreshResponse.addToErrDetails(write_ops::WriteError(
-            i, Status(ShardCannotRefreshDueToLocksHeldInfo(nss), "Catalog cache busy in refresh")));
-        ++i;
-    }
-
-    return cannotRefreshResponse.toBSON();
-}
-
 /**
  * Mimics a single shard backend for a particular collection which can be initialized with a
  * set of write command results to return.
@@ -335,12 +299,6 @@ public:
         });
     }
 
-    void expectInsertsReturnCannotRefreshErrors(const std::vector<BSONObj>& expected) {
-        onCommandForPoolExecutor([&](const executor::RemoteCommandRequest& request) {
-            return expectInsertsReturnCannotRefreshErrorsBase(nss, expected, request);
-        });
-    }
-
     void expectInsertsReturnError(const std::vector<BSONObj>& expected,
                                   const BatchedCommandResponse& errResponse) {
         onCommandForPoolExecutor([&](const executor::RemoteCommandRequest& request) {
@@ -397,6 +355,7 @@ TEST_F(BatchWriteExecTest, SingleOpUnordered) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Do single-target, single doc batch write op
     auto future = launchAsync([&] {
@@ -435,6 +394,7 @@ TEST_F(BatchWriteExecTest, SingleUpdateTargetsShardWithLet) {
                                                                        << "100")))});
         return updateOp;
     }());
+    updateRequest.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -520,6 +480,7 @@ TEST_F(BatchWriteExecTest, SingleDeleteTargetsShardWithLet) {
         deleteOp.setDeletes(std::vector{write_ops::DeleteOpEntry(q, false)});
         return deleteOp;
     }());
+    deleteRequest.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
 
@@ -605,6 +566,7 @@ TEST_F(BatchWriteExecTest, MultiOpLargeOrdered) {
         insertOp.setDocuments(docsToInsert);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -637,6 +599,7 @@ TEST_F(BatchWriteExecTest, SingleOpUnorderedError) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -677,6 +640,7 @@ TEST_F(BatchWriteExecTest, MultiOpLargeUnorderedWithStaleShardVersionError) {
         insertOp.setDocuments(docsToInsert);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -708,6 +672,7 @@ TEST_F(BatchWriteExecTest, StaleShardVersionReturnedFromBatchWithSingleMultiWrit
             write_ops::UpdateModification::parseFromClassicUpdate(BSON("Key" << 100)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -785,43 +750,6 @@ TEST_F(BatchWriteExecTest, StaleShardVersionReturnedFromBatchWithSingleMultiWrit
     ASSERT_EQ(3, response.getNModified());
 }
 
-TEST_F(BatchWriteExecTest, MultiOpLargeUnorderedWithCannotRefreshError) {
-    const int kNumDocsToInsert = 100'000;
-
-    std::vector<BSONObj> docsToInsert;
-    docsToInsert.reserve(kNumDocsToInsert);
-    for (int i = 0; i < kNumDocsToInsert; i++) {
-        docsToInsert.push_back(BSON("_id" << i));
-    }
-
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments(docsToInsert);
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(
-            operationContext(), singleShardNSTargeter, request, &response, &stats);
-
-        ASSERT(response.getOk());
-        ASSERT_EQ(kNumDocsToInsert, response.getN());
-    });
-
-    expectInsertsReturnCannotRefreshErrors({docsToInsert.begin(), docsToInsert.begin() + 60133});
-    expectInsertsReturnSuccess({docsToInsert.begin(), docsToInsert.begin() + 60133});
-    expectInsertsReturnSuccess({docsToInsert.begin() + 60133, docsToInsert.end()});
-
-    future.default_timed_get();
-}
-
 TEST_F(BatchWriteExecTest,
        RetryableErrorReturnedFromMultiWriteWithShard1AllOKShard2AllStaleShardVersion) {
     BatchedCommandRequest request([&] {
@@ -840,6 +768,7 @@ TEST_F(BatchWriteExecTest,
                 write_ops::UpdateModification::parseFromClassicUpdate(BSON("y" << 2)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -943,6 +872,7 @@ TEST_F(BatchWriteExecTest, RetryableErrorReturnedFromMultiWriteWithShard1Firs) {
                 write_ops::UpdateModification::parseFromClassicUpdate(BSON("y" << 2)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -1056,6 +986,7 @@ TEST_F(BatchWriteExecTest, RetryableErrorReturnedFromMultiWriteWithShard1FirstOK
                 write_ops::UpdateModification::parseFromClassicUpdate(BSON("y" << 2)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -1165,6 +1096,7 @@ TEST_F(BatchWriteExecTest, RetryableErrorReturnedFromWriteWithShard1SSVShard2OK)
             write_ops::UpdateModification::parseFromClassicUpdate(BSON("x" << 1)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -1264,6 +1196,7 @@ TEST_F(BatchWriteExecTest, StaleShardOp) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -1295,6 +1228,7 @@ TEST_F(BatchWriteExecTest, MultiStaleShardOp) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -1332,6 +1266,7 @@ TEST_F(BatchWriteExecTest, TooManyStaleShardOp) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -1366,6 +1301,7 @@ TEST_F(BatchWriteExecTest, StaleDbOp) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -1397,6 +1333,7 @@ TEST_F(BatchWriteExecTest, MultiStaleDbOp) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -1434,6 +1371,7 @@ TEST_F(BatchWriteExecTest, TooManyStaleDbOp) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -1457,73 +1395,6 @@ TEST_F(BatchWriteExecTest, TooManyStaleDbOp) {
     future.default_timed_get();
 }
 
-TEST_F(BatchWriteExecTest, MultiCannotRefreshShardOp) {
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments({BSON("x" << 1)});
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(
-            operationContext(), singleShardNSTargeter, request, &response, &stats);
-        ASSERT(response.getOk());
-    });
-
-    const std::vector<BSONObj> expected{BSON("x" << 1)};
-
-    // Return multiple ShardCannotRefreshDueToLocksHeld errors, but less than the give-up number
-    for (int i = 0; i < 3; i++) {
-        expectInsertsReturnCannotRefreshErrors(expected);
-    }
-
-    expectInsertsReturnSuccess(expected);
-
-    future.default_timed_get();
-}
-
-TEST_F(BatchWriteExecTest, TooManyCannotRefreshShardOp) {
-    // Retry op in exec too many times b/c of busy catalog cache (the error is not expected to
-    // trigger a refresh on any implementation of NSTargeter). We should report a no progress error
-    // for everything in the batch.
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(
-            operationContext(), singleShardNSTargeter, request, &response, &stats);
-        ASSERT(response.getOk());
-        ASSERT_EQ(0, response.getN());
-        ASSERT(response.isErrDetailsSet());
-        ASSERT_EQUALS(response.getErrDetailsAt(0).getStatus().code(), ErrorCodes::NoProgressMade);
-        ASSERT_EQUALS(response.getErrDetailsAt(1).getStatus().code(), ErrorCodes::NoProgressMade);
-    });
-
-    // Return multiple StaleShardVersion errors
-    for (int i = 0; i < (1 + kMaxRoundsWithoutProgress); i++) {
-        expectInsertsReturnCannotRefreshErrors({BSON("x" << 1), BSON("x" << 2)});
-    }
-
-    future.default_timed_get();
-}
-
 TEST_F(BatchWriteExecTest, RetryableWritesLargeBatch) {
     // A retryable error without a txnNumber is not retried.
 
@@ -1546,6 +1417,7 @@ TEST_F(BatchWriteExecTest, RetryableWritesLargeBatch) {
         insertOp.setDocuments(docsToInsert);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     operationContext()->setLogicalSessionId(makeLogicalSessionIdForTest());
     operationContext()->setTxnNumber(5);
@@ -1580,6 +1452,7 @@ TEST_F(BatchWriteExecTest, RetryableErrorNoTxnNumber) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     BatchedCommandResponse retryableErrResponse;
     retryableErrResponse.setStatus({ErrorCodes::NotWritablePrimary, "mock retryable error"});
@@ -1618,6 +1491,7 @@ TEST_F(BatchWriteExecTest, RetryableErrorTxnNumber) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     operationContext()->setLogicalSessionId(makeLogicalSessionIdForTest());
     operationContext()->setTxnNumber(5);
@@ -1655,6 +1529,7 @@ TEST_F(BatchWriteExecTest, NonRetryableErrorTxnNumber) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     operationContext()->setLogicalSessionId(makeLogicalSessionIdForTest());
     operationContext()->setTxnNumber(5);
@@ -1696,6 +1571,7 @@ TEST_F(BatchWriteExecTest, StaleEpochIsNotRetryable) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     operationContext()->setLogicalSessionId(makeLogicalSessionIdForTest());
     operationContext()->setTxnNumber(5);
@@ -1723,249 +1599,6 @@ TEST_F(BatchWriteExecTest, StaleEpochIsNotRetryable) {
     future.default_timed_get();
 }
 
-TEST_F(BatchWriteExecTest, FireAndForgetBatchInsertGetsReplyWithOnlyOkStatus) {
-    const int kNumDocsToInsert = 5;
-    const std::string kDocValue("sample");
-
-    std::vector<BSONObj> docsToInsert;
-    docsToInsert.reserve(kNumDocsToInsert);
-    for (int i = 0; i < kNumDocsToInsert; i++) {
-        docsToInsert.push_back(BSON("_id" << i << "otherField" << kDocValue));
-    }
-
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(true);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments(docsToInsert);
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        // Set Unacknowledged WC for a "fire & forget" request
-        auto opCtx = operationContext();
-        opCtx->setWriteConcern(
-            WriteConcernOptions::parse(WriteConcernOptions::Unacknowledged).getValue());
-        BatchWriteExec::executeBatch(opCtx, singleShardNSTargeter, request, &response, &stats);
-
-        // The reply should only contain an OK status, without any further detail on
-        // the ops actually executed across the cluster.
-        BatchedCommandResponse expectedReplyToFireAndForgetRequest;
-        expectedReplyToFireAndForgetRequest.setStatus(Status::OK());
-        ASSERT_EQUALS(response.toBSON().woCompare(expectedReplyToFireAndForgetRequest.toBSON()), 0);
-    });
-
-    expectInsertsReturnSuccess(docsToInsert.begin(), docsToInsert.end());
-
-    future.default_timed_get();
-}
-
-TEST_F(BatchWriteExecTest, FireAndForgetBatchUpdateGetsReplyWithOnlyOkStatus) {
-    BatchedCommandRequest request([&] {
-        write_ops::UpdateCommandRequest updateOp(nss);
-        updateOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        updateOp.setUpdates(std::vector{write_ops::UpdateOpEntry(
-            BSON("_id" << 100),
-            write_ops::UpdateModification::parseFromClassicUpdate(BSON("Key" << 100)))});
-        return updateOp;
-    }());
-
-    const static auto epoch = OID::gen();
-    const static Timestamp timestamp(2);
-
-    // This allows the batch to target each write operation to perform this test
-    class MultiShardTargeter : public MockNSTargeter {
-    public:
-        using MockNSTargeter::MockNSTargeter;
-
-        std::vector<ShardEndpoint> targetUpdate(OperationContext* opCtx,
-                                                const BatchItemRef& itemRef) const override {
-            if (targetAll) {
-                return std::vector{
-                    ShardEndpoint(
-                        kShardName1, ChunkVersion(100, 200, epoch, timestamp), boost::none),
-                    ShardEndpoint(
-                        kShardName2, ChunkVersion(101, 200, epoch, timestamp), boost::none)};
-            } else {
-                return std::vector{ShardEndpoint(
-                    kShardName2, ChunkVersion(101, 200, epoch, timestamp), boost::none)};
-            }
-        }
-
-        bool targetAll = true;
-    };
-
-    MultiShardTargeter multiShardNSTargeter(
-        nss,
-        {MockRange(
-             ShardEndpoint(kShardName1, ChunkVersion(100, 200, epoch, timestamp), boost::none),
-             BSON("sk" << MINKEY),
-             BSON("sk" << 10)),
-         MockRange(
-             ShardEndpoint(kShardName2, ChunkVersion(101, 200, epoch, timestamp), boost::none),
-             BSON("sk" << 10),
-             BSON("sk" << MAXKEY))});
-    auto future = launchAsync([&] {
-        // Set Unacknowledged WC for a "fire & forget" request
-        auto opCtx = operationContext();
-        opCtx->setWriteConcern(
-            WriteConcernOptions::parse(WriteConcernOptions::Unacknowledged).getValue());
-
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(opCtx, multiShardNSTargeter, request, &response, &stats);
-        return response;
-    });
-
-    onCommandForPoolExecutor([&](const RemoteCommandRequest& request) {
-        ASSERT_EQ(kTestShardHost1, request.target);
-
-        BatchedCommandResponse response;
-        response.setStatus(Status::OK());
-        response.setNModified(1);
-
-        return response.toBSON();
-    });
-
-    onCommandForPoolExecutor([&](const RemoteCommandRequest& request) {
-        ASSERT_EQ(kTestShardHost2, request.target);
-
-        BatchedCommandResponse response;
-        response.setStatus(Status::OK());
-        response.setNModified(0);
-        response.addToErrDetails(
-            write_ops::WriteError(0,
-                                  Status(StaleConfigInfo(nss,
-                                                         ChunkVersion(101, 200, epoch, timestamp),
-                                                         ChunkVersion(105, 200, epoch, timestamp),
-                                                         ShardId(kShardName2)),
-                                         "Stale error")));
-        return response.toBSON();
-    });
-
-    onCommandForPoolExecutor([&](const RemoteCommandRequest& request) {
-        ASSERT_EQ(kTestShardHost2, request.target);
-
-        BatchedCommandResponse response;
-        response.setStatus(Status::OK());
-        response.setNModified(2);
-
-        return response.toBSON();
-    });
-
-    // The reply should only contain an OK status, without any further detail on
-    // the ops actually executed across the cluster.
-    // (Despite of a "fire and forget" request, child batches still need to be internally processed
-    // before returning a reply).
-    auto response = future.default_timed_get();
-    BatchedCommandResponse expectedReplyToFireAndForgetRequest;
-    expectedReplyToFireAndForgetRequest.setStatus(Status::OK());
-    ASSERT_EQUALS(response.toBSON().woCompare(expectedReplyToFireAndForgetRequest.toBSON()), 0);
-}
-
-TEST_F(BatchWriteExecTest, FireAndForgetBatchDeleteGetsReplyWithOnlyOkStatus) {
-    // Try to update the single doc where a let param is used in the shard key.
-    const auto let = BSON("y" << 100);
-    const auto rtc = LegacyRuntimeConstants{Date_t::now(), Timestamp(1, 1)};
-    const auto q = BSON("x"
-                        << "$$y");
-    BatchedCommandRequest deleteRequest([&] {
-        write_ops::DeleteCommandRequest deleteOp(nss);
-        deleteOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        deleteOp.setLet(let);
-        deleteOp.setLegacyRuntimeConstants(rtc);
-        deleteOp.setDeletes(std::vector{write_ops::DeleteOpEntry(q, false)});
-        return deleteOp;
-    }());
-
-    const static auto epoch = OID::gen();
-
-    class MultiShardTargeter : public MockNSTargeter {
-    public:
-        using MockNSTargeter::MockNSTargeter;
-
-    protected:
-        std::vector<ShardEndpoint> targetDelete(OperationContext* opCtx,
-                                                const BatchItemRef& itemRef) const override {
-            return std::vector{ShardEndpoint(
-                kShardName2, ChunkVersion(101, 200, epoch, Timestamp(1, 1)), boost::none)};
-        }
-    };
-
-    MultiShardTargeter multiShardNSTargeter(
-        nss,
-        {MockRange(ShardEndpoint(
-                       kShardName1, ChunkVersion(100, 200, epoch, Timestamp(1, 1)), boost::none),
-                   BSON("x" << MINKEY),
-                   BSON("x" << 0)),
-         MockRange(ShardEndpoint(
-                       kShardName2, ChunkVersion(101, 200, epoch, Timestamp(1, 1)), boost::none),
-                   BSON("x" << 0),
-                   BSON("x" << MAXKEY))});
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-
-        // Set Unacknowledged WC for a "fire & forget" request
-        auto opCtx = operationContext();
-        opCtx->setWriteConcern(
-            WriteConcernOptions::parse(WriteConcernOptions::Unacknowledged).getValue());
-
-        BatchWriteExec::executeBatch(opCtx, multiShardNSTargeter, deleteRequest, &response, &stats);
-
-        return response;
-    });
-
-    // The update will hit the first shard.
-    onCommandForPoolExecutor(
-        [&](const RemoteCommandRequest& request) {
-            ASSERT_EQ(kTestShardHost2, request.target);
-
-            BatchedCommandResponse response;
-            response.setStatus(Status::OK());
-
-            // Check that let params are propagated to shards.
-            const auto opMsgRequest(OpMsgRequest::fromDBAndBody(request.dbname, request.cmdObj));
-            const auto actualBatchedUpdate(BatchedCommandRequest::parseDelete(opMsgRequest));
-            ASSERT_BSONOBJ_EQ(let, actualBatchedUpdate.getLet().value_or(BSONObj()));
-            ASSERT_EQUALS(actualBatchedUpdate.getLegacyRuntimeConstants()->getLocalNow(),
-                          rtc.getLocalNow());
-            ASSERT_EQUALS(actualBatchedUpdate.getLegacyRuntimeConstants()->getClusterTime(),
-                          rtc.getClusterTime());
-
-            // Check that let params are only forwarded and not evaluated.
-            auto expectedQ = BSON("x"
-                                  << "$$y");
-            for (auto&& u : actualBatchedUpdate.getDeleteRequest().getDeletes())
-                ASSERT_BSONOBJ_EQ(expectedQ, u.getQ());
-
-            return response.toBSON();
-        });
-
-    // The reply should only contain an OK status, without any further detail on
-    // the ops actually executed across the cluster.
-    // (Despite of a "fire and forget" request, child batches still need to be internally processed
-    // before returning a reply).
-    auto response = future.default_timed_get();
-    BatchedCommandResponse expectedReplyToFireAndForgetRequest;
-    expectedReplyToFireAndForgetRequest.setStatus(Status::OK());
-    ASSERT_EQUALS(response.toBSON().woCompare(expectedReplyToFireAndForgetRequest.toBSON()), 0);
-}
-
 TEST_F(BatchWriteExecTest, TenantMigrationAbortedErrorOrderedOp) {
     const std::vector<BSONObj> expected{BSON("x" << 1), BSON("x" << 2), BSON("x" << 3)};
     BatchedCommandRequest request([&] {
@@ -1978,6 +1611,7 @@ TEST_F(BatchWriteExecTest, TenantMigrationAbortedErrorOrderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -2008,6 +1642,7 @@ TEST_F(BatchWriteExecTest, TenantMigrationAbortedErrorUnorderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -2038,6 +1673,7 @@ TEST_F(BatchWriteExecTest, MultipleTenantMigrationAbortedErrorUnorderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const int numTenantMigrationAbortedErrors = 3;
 
@@ -2072,6 +1708,7 @@ TEST_F(BatchWriteExecTest, MultipleTenantMigrationAbortedErrorOrderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const int numTenantMigrationAbortedErrors = 3;
 
@@ -2106,6 +1743,7 @@ TEST_F(BatchWriteExecTest, PartialTenantMigrationAbortedErrorOrderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -2138,6 +1776,7 @@ TEST_F(BatchWriteExecTest, PartialTenantMigrationErrorUnorderedOp) {
         insertOp.setDocuments(expected);
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     // Execute request
     auto future = launchAsync([&] {
@@ -2222,6 +1861,7 @@ TEST_F(BatchWriteExecTargeterErrorTest, TargetedFailedAndErrorResponse) {
             write_ops::UpdateModification::parseFromClassicUpdate(BSON("Key" << 100)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -2357,6 +1997,7 @@ TEST_F(BatchWriteExecTransactionTargeterErrorTest, TargetedFailedAndErrorRespons
             write_ops::UpdateModification::parseFromClassicUpdate(BSON("Key" << 100)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -2500,6 +2141,7 @@ TEST_F(BatchWriteExecTransactionMultiShardTest, TargetedSucceededAndErrorRespons
             write_ops::UpdateModification::parseFromClassicUpdate(BSON("Key" << 100)))});
         return updateOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     const static auto epoch = OID::gen();
     const static Timestamp timestamp(2);
@@ -2625,22 +2267,6 @@ public:
         });
     }
 
-    void expectInsertsReturnCannotRefreshErrors(const std::vector<BSONObj>& expected) {
-        onCommandForPoolExecutor([&](const executor::RemoteCommandRequest& request) {
-            BSONObjBuilder bob;
-
-            bob.appendElementsUnique(
-                expectInsertsReturnCannotRefreshErrorsBase(nss, expected, request));
-
-            // Because this is the transaction-specific fixture, return transaction metadata in
-            // the response.
-            TxnResponseMetadata txnResponseMetadata(false /* readOnly */);
-            txnResponseMetadata.serialize(&bob);
-
-            return bob.obj();
-        });
-    }
-
     void expectInsertsReturnTransientTxnErrors(const std::vector<BSONObj>& expected) {
         onCommandForPoolExecutor([&](const executor::RemoteCommandRequest& request) {
             ASSERT_EQUALS(nss.db(), request.dbname);
@@ -2690,6 +2316,7 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchThrows_CommandError) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -2721,6 +2348,7 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_WriteError) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -2750,6 +2378,7 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_WriteErrorOrdered) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -2768,64 +2397,6 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_WriteErrorOrdered) {
     future.default_timed_get();
 }
 
-TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_WriteErrorFromBusyCache) {
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(false);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(
-            operationContext(), singleShardNSTargeter, request, &response, &stats);
-
-        ASSERT(response.isErrDetailsSet());
-        ASSERT_GT(response.sizeErrDetails(), 0u);
-        ASSERT_EQ(ErrorCodes::ShardCannotRefreshDueToLocksHeld,
-                  response.getErrDetailsAt(0).getStatus().code());
-    });
-
-    expectInsertsReturnCannotRefreshErrors({BSON("x" << 1), BSON("x" << 2)});
-
-    future.default_timed_get();
-}
-
-TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_WriteErrorOrderedFromBusyCache) {
-    BatchedCommandRequest request([&] {
-        write_ops::InsertCommandRequest insertOp(nss);
-        insertOp.setWriteCommandRequestBase([] {
-            write_ops::WriteCommandRequestBase writeCommandBase;
-            writeCommandBase.setOrdered(true);
-            return writeCommandBase;
-        }());
-        insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
-        return insertOp;
-    }());
-
-    auto future = launchAsync([&] {
-        BatchedCommandResponse response;
-        BatchWriteExecStats stats;
-        BatchWriteExec::executeBatch(
-            operationContext(), singleShardNSTargeter, request, &response, &stats);
-
-        ASSERT(response.isErrDetailsSet());
-        ASSERT_GT(response.sizeErrDetails(), 0u);
-        ASSERT_EQ(ErrorCodes::ShardCannotRefreshDueToLocksHeld,
-                  response.getErrDetailsAt(0).getStatus().code());
-    });
-
-    expectInsertsReturnCannotRefreshErrors({BSON("x" << 1), BSON("x" << 2)});
-
-    future.default_timed_get();
-}
-
 TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_TransientTxnError) {
     BatchedCommandRequest request([&] {
         write_ops::InsertCommandRequest insertOp(nss);
@@ -2837,13 +2408,16 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_TransientTxnError) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
         BatchWriteExecStats stats;
-        ASSERT_THROWS(BatchWriteExec::executeBatch(
-                          operationContext(), singleShardNSTargeter, request, &response, &stats),
-                      WriteConflictException);
+        ASSERT_THROWS_CODE(
+            BatchWriteExec::executeBatch(
+                operationContext(), singleShardNSTargeter, request, &response, &stats),
+            AssertionException,
+            ErrorCodes::WriteConflict);
     });
 
     expectInsertsReturnTransientTxnErrors({BSON("x" << 1), BSON("x" << 2)});
@@ -2862,6 +2436,7 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_DispatchError) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
@@ -2893,6 +2468,7 @@ TEST_F(BatchWriteExecTransactionTest, ErrorInBatchSets_TransientDispatchError) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSONObj());
 
     auto future = launchAsync([&] {
         BatchedCommandResponse response;
diff --git a/src/mongo/s/write_ops/batch_write_op.cpp b/src/mongo/s/write_ops/batch_write_op.cpp
index ed67f6c0088..a61ee3dd4bf 100644
--- a/src/mongo/s/write_ops/batch_write_op.cpp
+++ b/src/mongo/s/write_ops/batch_write_op.cpp
@@ -59,6 +59,7 @@ struct WriteErrorComp {
 // batches before serializing.
 //
 // TODO: Revisit when we revisit command limits in general
+const int kEstUpdateOverheadBytes = (BSONObjMaxInternalSize - BSONObjMaxUserSize) / 100;
 const int kEstDeleteOverheadBytes = (BSONObjMaxInternalSize - BSONObjMaxUserSize) / 100;
 
 /**
@@ -158,17 +159,51 @@ int getWriteSizeBytes(const WriteOp& writeOp) {
         return item.getDocument().objsize();
     } else if (batchType == BatchedCommandRequest::BatchType_Update) {
         // Note: Be conservative here - it's okay if we send slightly too many batches.
-        const auto& update = item.getUpdate();
-        auto estSize = write_ops::getUpdateSizeEstimate(update.getQ(),
-                                                        update.getU(),
-                                                        update.getC(),
-                                                        update.getUpsertSupplied().has_value(),
-                                                        update.getCollation(),
-                                                        update.getArrayFilters(),
-                                                        update.getHint());
+        auto estSize = static_cast<int>(BSONObj::kMinBSONLength);
+        static const auto boolSize = 1;
+
+        // Add the size of the 'collation' field, if present.
+        estSize += !item.getUpdate().getCollation() ? 0
+                                                    : (UpdateOpEntry::kCollationFieldName.size() +
+                                                       item.getUpdate().getCollation()->objsize());
+
+        // Add the size of the 'arrayFilters' field, if present.
+        estSize += !item.getUpdate().getArrayFilters() ? 0 : ([&item]() {
+            auto size = BSONObj::kMinBSONLength + UpdateOpEntry::kArrayFiltersFieldName.size();
+            for (auto&& filter : *item.getUpdate().getArrayFilters()) {
+                size += filter.objsize();
+            }
+            return size;
+        })();
+
+        // Add the sizes of the 'multi' and 'upsert' fields.
+        estSize += UpdateOpEntry::kUpsertFieldName.size() + boolSize;
+        estSize += UpdateOpEntry::kMultiFieldName.size() + boolSize;
+
+        // Add the size of 'upsertSupplied' field if present.
+        if (auto upsertSupplied = item.getUpdate().getUpsertSupplied()) {
+            estSize += UpdateOpEntry::kUpsertSuppliedFieldName.size() + boolSize;
+        }
+
+        // Add the sizes of the 'q' and 'u' fields.
+        estSize += (UpdateOpEntry::kQFieldName.size() + item.getUpdate().getQ().objsize() +
+                    UpdateOpEntry::kUFieldName.size() + item.getUpdate().getU().objsize());
+
+        // Add the size of the 'c' field if present.
+        if (auto constants = item.getUpdate().getC()) {
+            estSize += UpdateOpEntry::kCFieldName.size() + item.getUpdate().getC()->objsize();
+        }
+
+        // Add the size of 'hint' field if present.
+        if (auto hint = item.getUpdate().getHint(); !hint.isEmpty()) {
+            estSize += UpdateOpEntry::kHintFieldName.size() + hint.objsize();
+        }
+
+        // Finally, add the constant updateOp overhead size.
+        estSize += kEstUpdateOverheadBytes;
 
         // When running a debug build, verify that estSize is at least the BSON serialization size.
-        dassert(estSize >= update.toBSON().objsize());
+        dassert(estSize >= item.getUpdate().toBSON().objsize());
         return estSize;
     } else if (batchType == BatchedCommandRequest::BatchType_Delete) {
         // Note: Be conservative here - it's okay if we send slightly too many batches.
@@ -568,9 +603,6 @@ BatchedCommandRequest BatchWriteOp::buildBatchRequest(const TargetedWriteBatch&
             wcb.setStmtIds(std::move(stmtIdsForOp));
         }
 
-        wcb.setBypassEmptyTsReplacement(
-            _clientRequest.getWriteCommandRequestBase().getBypassEmptyTsReplacement());
-
         return wcb;
     }());
 
@@ -583,6 +615,19 @@ BatchedCommandRequest BatchWriteOp::buildBatchRequest(const TargetedWriteBatch&
     if (dbVersion)
         request.setDbVersion(*dbVersion);
 
+    if (_clientRequest.hasWriteConcern()) {
+        if (_clientRequest.isVerboseWC()) {
+            request.setWriteConcern(_clientRequest.getWriteConcern());
+        } else {
+            // Mongos needs to send to the shard with w > 0 so it will be able to see the
+            // writeErrors
+            request.setWriteConcern(upgradeWriteConcern(_clientRequest.getWriteConcern()));
+        }
+    } else if (!TransactionRouter::get(_opCtx)) {
+        // Apply the WC from the opCtx (except if in a transaction).
+        request.setWriteConcern(_opCtx->getWriteConcern().toBSON());
+    }
+
     return request;
 }
 
@@ -765,7 +810,7 @@ void BatchWriteOp::buildClientResponse(BatchedCommandResponse* batchResp) {
     batchResp->setStatus(Status::OK());
 
     // For non-verbose, it's all we need.
-    if (!_opCtx->getWriteConcern().requiresWriteAcknowledgement()) {
+    if (!_clientRequest.isVerboseWC()) {
         return;
     }
 
@@ -816,7 +861,12 @@ void BatchWriteOp::buildClientResponse(BatchedCommandResponse* batchResp) {
         }
     }
 
-    if (!_wcErrors.empty()) {
+    // Only return a write concern error if everything succeeded (unordered or ordered)
+    // OR if something succeeded and we're unordered
+    const bool orderedOps = _clientRequest.getWriteCommandRequestBase().getOrdered();
+    const bool reportWCError =
+        errOps.empty() || (!orderedOps && errOps.size() < _clientRequest.sizeWriteOps());
+    if (!_wcErrors.empty() && reportWCError) {
         WriteConcernErrorDetail* error = new WriteConcernErrorDetail;
 
         // Generate the multi-error message below
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 b21e64c6d53..bfda09f0814 100644
--- a/src/mongo/s/write_ops/batch_write_op_test.cpp
+++ b/src/mongo/s/write_ops/batch_write_op_test.cpp
@@ -32,7 +32,6 @@
 #include "mongo/s/concurrency/locker_mongos_client_observer.h"
 #include "mongo/s/mock_ns_targeter.h"
 #include "mongo/s/session_catalog_router.h"
-#include "mongo/s/shard_cannot_refresh_due_to_locks_held_exception.h"
 #include "mongo/s/sharding_router_test_fixture.h"
 #include "mongo/s/transaction_router.h"
 #include "mongo/s/write_ops/batch_write_op.h"
@@ -235,6 +234,7 @@ TEST_F(BatchWriteOpTest, SingleWriteConcernErrorOrdered) {
         insertOp.setDocuments({BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSON("w" << 3));
 
     BatchWriteOp batchOp(_opCtx, request);
 
@@ -246,6 +246,7 @@ TEST_F(BatchWriteOpTest, SingleWriteConcernErrorOrdered) {
 
     BatchedCommandRequest targetBatch =
         batchOp.buildBatchRequest(*targeted.begin()->second, targeter);
+    ASSERT(targetBatch.getWriteConcern().woCompare(request.getWriteConcern()) == 0);
 
     BatchedCommandResponse response;
     buildResponse(1, &response);
@@ -304,22 +305,12 @@ TEST_F(BatchWriteOpTest, SingleStaleError) {
     batchOp.noteBatchResponse(*targeted.begin()->second, response, nullptr);
     ASSERT(!batchOp.isFinished());
 
-    // Respond with a ShardCannotRefreshDueToLocksHeld error; the batch should still be retriable.
-    targeted.clear();
-    ASSERT_OK(batchOp.targetBatch(targeter, false, &targeted));
-    buildResponse(0, &response);
-    response.addToErrDetails(write_ops::WriteError(
-        0, Status{ShardCannotRefreshDueToLocksHeldInfo(nss), "mock cache busy error"}));
-
-    batchOp.noteBatchResponse(*targeted.begin()->second, response, nullptr);
-    ASSERT(!batchOp.isFinished());
-
-    // Respond with an 'ok' response
     targeted.clear();
     ASSERT_OK(batchOp.targetBatch(targeter, false, &targeted));
 
     buildResponse(1, &response);
 
+    // Respond with an 'ok' response
     batchOp.noteBatchResponse(*targeted.begin()->second, response, nullptr);
     ASSERT(batchOp.isFinished());
 
@@ -1010,7 +1001,9 @@ TEST_F(BatchWriteOpTest, MultiOpPartialSingleShardErrorOrdered) {
 // Tests of edge-case functionality, lifecycle is assumed to be behaving normally
 //
 
-// Multi-op (unordered) error and write concern error test.
+// Multi-op (unordered) error and write concern error test. We never report the write concern error
+// for single-doc batches, since the error means there's no write concern applied. Don't suppress
+// the error if ordered : false.
 TEST_F(BatchWriteOpTest, MultiOpErrorAndWriteConcernErrorUnordered) {
     NamespaceString nss("foo.bar");
     ShardEndpoint endpoint(ShardId("shard"), ChunkVersion::IGNORED(), boost::none);
@@ -1027,6 +1020,7 @@ TEST_F(BatchWriteOpTest, MultiOpErrorAndWriteConcernErrorUnordered) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 1)});
         return insertOp;
     }());
+    request.setWriteConcern(BSON("w" << 3));
 
     BatchWriteOp batchOp(_opCtx, request);
 
@@ -1051,7 +1045,8 @@ TEST_F(BatchWriteOpTest, MultiOpErrorAndWriteConcernErrorUnordered) {
     ASSERT(clientResponse.isWriteConcernErrorSet());
 }
 
-// Single-op (ordered) error and write concern error test.
+// Single-op (ordered) error and write concern error test. Suppress the write concern error if
+// ordered and we also have an error
 TEST_F(BatchWriteOpTest, SingleOpErrorAndWriteConcernErrorOrdered) {
     NamespaceString nss("foo.bar");
     ShardEndpoint endpointA(ShardId("shardA"), ChunkVersion::IGNORED(), boost::none);
@@ -1069,6 +1064,7 @@ TEST_F(BatchWriteOpTest, SingleOpErrorAndWriteConcernErrorOrdered) {
         updateOp.setUpdates({buildUpdate(BSON("x" << GTE << -1 << LT << 2), true)});
         return updateOp;
     }());
+    request.setWriteConcern(BSON("w" << 3));
 
     BatchWriteOp batchOp(_opCtx, request);
 
@@ -1095,14 +1091,14 @@ TEST_F(BatchWriteOpTest, SingleOpErrorAndWriteConcernErrorOrdered) {
     ASSERT(batchOp.isFinished());
     ASSERT(++targetedIt == targeted.end());
 
-    // Ordered reports write concern error.
+    // Ordered doesn't report write concern error
     BatchedCommandResponse clientResponse;
     batchOp.buildClientResponse(&clientResponse);
     ASSERT(clientResponse.getOk());
     ASSERT_EQUALS(clientResponse.getN(), 1);
     ASSERT(clientResponse.isErrDetailsSet());
     ASSERT_EQUALS(clientResponse.sizeErrDetails(), 1u);
-    ASSERT(clientResponse.isWriteConcernErrorSet());
+    ASSERT(!clientResponse.isWriteConcernErrorSet());
 }
 
 // Targeting failure on second op in batch op (ordered)
@@ -1411,6 +1407,7 @@ TEST_F(BatchWriteOpTest, MultiOpTwoWCErrors) {
         insertOp.setDocuments({BSON("x" << -1), BSON("x" << 2)});
         return insertOp;
     }());
+    request.setWriteConcern(BSON("w" << 3));
 
     BatchWriteOp batchOp(_opCtx, request);
 
diff --git a/src/mongo/s/write_ops/batched_command_request.cpp b/src/mongo/s/write_ops/batched_command_request.cpp
index 185857d6acc..107f1a49204 100644
--- a/src/mongo/s/write_ops/batched_command_request.cpp
+++ b/src/mongo/s/write_ops/batched_command_request.cpp
@@ -38,6 +38,8 @@
 namespace mongo {
 namespace {
 
+const auto kWriteConcern = "writeConcern"_sd;
+
 template <class T>
 BatchedCommandRequest constructBatchedCommandRequest(const OpMsgRequest& request) {
     auto batchRequest = BatchedCommandRequest{T::parse(request)};
@@ -51,6 +53,11 @@ BatchedCommandRequest constructBatchedCommandRequest(const OpMsgRequest& request
         batchRequest.setShardVersion(shardVersion);
     }
 
+    auto writeConcernField = request.body[kWriteConcern];
+    if (!writeConcernField.eoo()) {
+        batchRequest.setWriteConcern(writeConcernField.Obj());
+    }
+
     // The 'isTimeseriesNamespace' is an internal parameter used for communication between mongos
     // and mongod.
     auto isTimeseriesNamespace =
@@ -166,9 +173,19 @@ const boost::optional<BSONObj>& BatchedCommandRequest::getLet() const {
     return _visit(Visitor{});
 };
 
-const OptionalBool& BatchedCommandRequest::getBypassEmptyTsReplacement() const {
-    return _visit([](auto&& op) -> decltype(auto) { return op.getBypassEmptyTsReplacement(); });
-};
+bool BatchedCommandRequest::isVerboseWC() const {
+    if (!hasWriteConcern()) {
+        return true;
+    }
+
+    BSONObj writeConcern = getWriteConcern();
+    BSONElement wElem = writeConcern["w"];
+    if (!wElem.isNumber() || wElem.Number() != 0) {
+        return true;
+    }
+
+    return false;
+}
 
 const write_ops::WriteCommandRequestBase& BatchedCommandRequest::getWriteCommandRequestBase()
     const {
@@ -189,6 +206,10 @@ void BatchedCommandRequest::serialize(BSONObjBuilder* builder) const {
     if (_dbVersion) {
         builder->append("databaseVersion", _dbVersion->toBSON());
     }
+
+    if (_writeConcern) {
+        builder->append(kWriteConcern, *_writeConcern);
+    }
 }
 
 BSONObj BatchedCommandRequest::toBSON() const {
diff --git a/src/mongo/s/write_ops/batched_command_request.h b/src/mongo/s/write_ops/batched_command_request.h
index 0bcb51a3556..eea7f7bbe11 100644
--- a/src/mongo/s/write_ops/batched_command_request.h
+++ b/src/mongo/s/write_ops/batched_command_request.h
@@ -52,25 +52,15 @@ public:
         : _batchType(BatchType_Insert),
           _insertReq(std::make_unique<write_ops::InsertCommandRequest>(std::move(insertOp))) {}
 
-    BatchedCommandRequest(std::unique_ptr<write_ops::InsertCommandRequest> insertOp)
-        : _batchType(BatchType_Insert), _insertReq(std::move(insertOp)) {}
-
     BatchedCommandRequest(write_ops::UpdateCommandRequest updateOp)
         : _batchType(BatchType_Update),
           _updateReq(std::make_unique<write_ops::UpdateCommandRequest>(std::move(updateOp))) {}
 
-    BatchedCommandRequest(std::unique_ptr<write_ops::UpdateCommandRequest> updateOp)
-        : _batchType(BatchType_Update), _updateReq(std::move(updateOp)) {}
-
     BatchedCommandRequest(write_ops::DeleteCommandRequest deleteOp)
         : _batchType(BatchType_Delete),
           _deleteReq(std::make_unique<write_ops::DeleteCommandRequest>(std::move(deleteOp))) {}
 
-    BatchedCommandRequest(std::unique_ptr<write_ops::DeleteCommandRequest> deleteOp)
-        : _batchType(BatchType_Delete), _deleteReq(std::move(deleteOp)) {}
-
     BatchedCommandRequest(BatchedCommandRequest&&) = default;
-    BatchedCommandRequest& operator=(BatchedCommandRequest&&) = default;
 
     static BatchedCommandRequest parseInsert(const OpMsgRequest& request);
     static BatchedCommandRequest parseUpdate(const OpMsgRequest& request);
@@ -101,19 +91,26 @@ public:
         return *_deleteReq;
     }
 
-    std::unique_ptr<write_ops::InsertCommandRequest> extractInsertRequest() {
-        return std::move(_insertReq);
+    std::size_t sizeWriteOps() const;
+
+    void setWriteConcern(const BSONObj& writeConcern) {
+        _writeConcern = writeConcern.getOwned();
     }
 
-    std::unique_ptr<write_ops::UpdateCommandRequest> extractUpdateRequest() {
-        return std::move(_updateReq);
+    void unsetWriteConcern() {
+        _writeConcern = boost::none;
     }
 
-    std::unique_ptr<write_ops::DeleteCommandRequest> extractDeleteRequest() {
-        return std::move(_deleteReq);
+    bool hasWriteConcern() const {
+        return _writeConcern.is_initialized();
     }
 
-    std::size_t sizeWriteOps() const;
+    const BSONObj& getWriteConcern() const {
+        invariant(_writeConcern);
+        return *_writeConcern;
+    }
+
+    bool isVerboseWC() const;
 
     void setShardVersion(ChunkVersion shardVersion) {
         _shardVersion = std::move(shardVersion);
@@ -149,7 +146,6 @@ public:
 
     const boost::optional<LegacyRuntimeConstants>& getLegacyRuntimeConstants() const;
     const boost::optional<BSONObj>& getLet() const;
-    const OptionalBool& getBypassEmptyTsReplacement() const;
 
     const write_ops::WriteCommandRequestBase& getWriteCommandRequestBase() const;
     void setWriteCommandRequestBase(write_ops::WriteCommandRequestBase writeCommandBase);
@@ -232,6 +228,8 @@ private:
 
     boost::optional<ChunkVersion> _shardVersion;
     boost::optional<DatabaseVersion> _dbVersion;
+
+    boost::optional<BSONObj> _writeConcern;
 };
 
 /**
diff --git a/src/mongo/s/write_ops/batched_command_request_test.cpp b/src/mongo/s/write_ops/batched_command_request_test.cpp
index be0728b1533..9a5e968f10d 100644
--- a/src/mongo/s/write_ops/batched_command_request_test.cpp
+++ b/src/mongo/s/write_ops/batched_command_request_test.cpp
@@ -92,12 +92,14 @@ TEST(BatchedCommandRequest, InsertCloneWithIds) {
         insertOp.setDocuments({BSON("x" << 1), BSON("x" << 2)});
         return insertOp;
     }());
+    batchedRequest.setWriteConcern(BSON("w" << 2));
 
     const auto clonedRequest(BatchedCommandRequest::cloneInsertWithIds(std::move(batchedRequest)));
 
     ASSERT_EQ("xyz.abc", clonedRequest.getNS().ns());
     ASSERT(clonedRequest.getWriteCommandRequestBase().getOrdered());
     ASSERT(clonedRequest.getWriteCommandRequestBase().getBypassDocumentValidation());
+    ASSERT_BSONOBJ_EQ(BSON("w" << 2), clonedRequest.getWriteConcern());
 
     const auto& insertDocs = clonedRequest.getInsertRequest().getDocuments();
     ASSERT_EQ(2u, insertDocs.size());
diff --git a/src/mongo/s/write_ops/write_op.cpp b/src/mongo/s/write_ops/write_op.cpp
index 6b33d3b9312..236c7efbc94 100644
--- a/src/mongo/s/write_ops/write_op.cpp
+++ b/src/mongo/s/write_ops/write_op.cpp
@@ -29,24 +29,7 @@
 
 #include "mongo/s/write_ops/write_op.h"
 
-
-#include <absl/container/flat_hash_set.h>
-#include <algorithm>
-#include <boost/move/utility_core.hpp>
-#include <boost/none.hpp>
-#include <boost/optional/optional.hpp>
-#include <ostream>
-#include <string>
-
-#include "mongo/base/error_codes.h"
-#include "mongo/base/status.h"
-#include "mongo/bson/bsonobjbuilder.h"
-#include "mongo/db/catalog/collection_uuid_mismatch_info.h"
-#include "mongo/db/stats/counters.h"
-#include "mongo/s/sharding_feature_flags_gen.h"
 #include "mongo/s/transaction_router.h"
-#include "mongo/s/write_ops/batch_write_op.h"
-#include "mongo/s/write_ops/batched_command_request.h"
 #include "mongo/util/assert_util.h"
 
 namespace mongo {
@@ -96,16 +79,6 @@ write_ops::WriteError combineOpErrors(const std::vector<ChildWriteOp const*>& er
                                  Status(MultipleErrorsOccurredInfo(errB.arr()), msg.str()));
 }
 
-bool isSafeToIgnoreErrorInPartiallyAppliedOp(write_ops::WriteError& error) {
-    // UUID mismatch errors are safe to ignore if the actualCollection is null in conjuntion with
-    // other successful operations. This is true because it means we wrongly targeted a non-owning
-    // shard with the operation and we wouldn't have applied any modifications anyway.
-    //
-    // Note this is only safe if we're using ShardVersion::IGNORED since we're ignoring any
-    // placement concern and broadcasting to all shards.
-    return error.getStatus().code() == ErrorCodes::CollectionUUIDMismatch &&
-        !error.getStatus().extraInfo<CollectionUUIDMismatchInfo>()->actualCollection();
-}
 }  // namespace
 
 const BatchItemRef& WriteOp::getWriteItem() const {
@@ -209,29 +182,7 @@ void WriteOp::_updateOpState() {
         _state = WriteOpState_Ready;
     } else if (!childErrors.empty()) {
         _error = combineOpErrors(childErrors);
-        bool isTargetingAllShardsWithSVIgnored =
-            childErrors.front()
-                ->endpoint->shardVersion
-                .map([&](const auto& cv) { return ChunkVersion::isIgnoredVersion(cv); })
-                .get_value_or(false);
-        // There are errors that are safe to ignore if they were correctly applied to other shards
-        // and we're using ShardVersion::IGNORED. They are safe to ignore as they can be interpreted
-        // as no-ops if the shard response had been instead a successful result since they wouldn't
-        // have modified any data. As a result, we can swallow the errors and treat them as a
-        // successful operation.
-        if (isTargetingAllShardsWithSVIgnored && isSafeToIgnoreErrorInPartiallyAppliedOp(*_error) &&
-            !_successfulShardSet.empty()) {
-            if (!hasPendingChild) {
-                _error.reset();
-                _state = WriteOpState_Completed;
-            } else {
-                // As this error is acceptable we wait until all other operations finish to take a
-                // decision.
-                return;
-            }
-        } else {
-            _state = WriteOpState_Error;
-        }
+        _state = WriteOpState_Error;
     } else if (hasPendingChild && _inTxn) {
         // Return early here since this means that there were no errors while in txn
         // but there are still ops that have not yet finished.