                 me.remove(connectionId: connectionId)
             }
             
-            return PooledConnection(host: host, connection: connection)
+            return self.updateSDAM(from: connection.handshakeResult).map {
+                return PooledConnection(host: host, connection: connection)
+            }
         }
         
         connection.whenFailure { error in

            } catch { }
        }
        
        for host in self.hosts {
            if !discoveredHosts.contains(host) {
                makeConnection(to: host).whenSuccess { pooledConnection in
                    self.pool.append(pooledConnection)
                }
            }
        }
    }
    
    private func makeConnection(to host: ConnectionSettings.Host) -> EventLoopFuture<PooledConnection> {
        discoveredHosts.insert(host)
        
        // TODO: Failed to connect, different host until all hosts have been had
        let connection = Connection.connect(
            for: self,
            host: host
        ).map { connection -> PooledConnection in
            connection.slaveOk = self.slaveOk
            
            /// Ensures we default to the cluster's lowest version

    }
    private var timeoutHosts = Set<ConnectionSettings.Host>()
    
    private func updateSDAM(from handshake: ConnectionHandshakeReply?) -> EventLoopFuture<Void> {
        var hosts = handshake?.hosts ?? []
        hosts += handshake?.passives ?? []
        
        for host in hosts {
            do {
