config/toml.go

@@ -480,6 +480,8 @@ only_internal_wal = "{{ .Consensus.OnlyInternalWal }}"
 wal_file = "{{ js .Consensus.WalPath }}"
 
 # How long we wait for a proposal block before prevoting nil
+# Deprecated: timeout_commit is overridden by the state machine in app version >= 3.
+# Therefore, the value set in this config will be ignored.
 timeout_propose = "{{ .Consensus.TimeoutPropose }}"
 # How much timeout_propose increases with each round
 timeout_propose_delta = "{{ .Consensus.TimeoutProposeDelta }}"
@@ -494,6 +496,8 @@ timeout_precommit_delta = "{{ .Consensus.TimeoutPrecommitDelta }}"
 # How long we wait after committing a block, before starting on the new
 # height (this gives us a chance to receive some more precommits, even
 # though we already have +2/3).
+# Deprecated: timeout_commit is overridden by the state machine in app version >= 3.
+# Therefore, the value set in this config will be ignored.
 timeout_commit = "{{ .Consensus.TimeoutCommit }}"
 
 # How many blocks to look back to check existence of the node's consensus votes before joining consensus

docs/celestia-architecture/adr-001-block-propagation.md

@@ -102,7 +102,7 @@ When a user requests a block from the LL node, the request will be set to the IP
 
 ![user request flow](./assets/user-request.png)
 
-The goal is to not change the public interface for RPC's. It is yet to be seen if this possible. This means that CIDs will need to be set and loaded from the store in order to get all the related block information an user requires.
+The goal is to not change the public interface for RPC's. It is yet to be seen if this possible. This means that CIDs will need to be set and loaded from the store in order to get all the related block information a user requires.
 
 ## Status
 

docs/celestia-architecture/adr-006-row-propagation.md

@@ -69,7 +69,7 @@ decrease the number of required changes. Below, implementation semantics are pre
 // Row represents a blob of multiple ExtendedDataSquare shares.
 // Practically, it is half of an extended row, as other half can be recomputed.
 type Row struct {
-// Index is an top-to-bottom index of a Row in ExtendedDataSquare.
+// Index is a top-to-bottom index of a Row in ExtendedDataSquare.
 // NOTE: Row Index is unnecessary, as we can determine it's Index by hash from DAHeader. However, Index removal
 // would bring more changes to Consensus Reactor with arguable pros of less bandwidth usage.
 Index int
@@ -199,4 +199,4 @@ Proposed
     comparison. The actual data size in such a case for the Row would be 128x256(shares_per_row*share_size)=32KiB, which
     is exactly two times smaller than a Part.
 * Gossiped chunks are no longer constant size. Instead, their size is proportional to the size of Block's data.
-* Another step back from original Tendermint's codebases
+* Another step back from original Tendermint's codebases

docs/celestia-architecture/adr-template.md

@@ -10,7 +10,7 @@
 
 ## Alternative Approaches
 
-> This section contains information around alternative options that are considered before making a decision. It should contain a explanation on why the alternative approach(es) were not chosen.
+> This section contains information around alternative options that are considered before making a decision. It should contain an explanation on why the alternative approach(es) were not chosen.
 
 ## Decision
 

mempool/cat/pool.go

@@ -3,13 +3,10 @@ package cat
 import (
 	"errors"
 	"fmt"
-	"runtime"
 	"sort"
 	"sync"
 	"time"
 
-	"github.com/creachadair/taskgroup"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
@@ -672,36 +669,31 @@ func (txmp *TxPool) recheckTransactions() {
 	)
 
 	// Collect transactions currently in the mempool requiring recheck.
+	// TODO: we are iterating over a map, which may scramble the order of transactions
+	// such that they are not in order, dictated by nonce and then priority. This may
+	// cause transactions to needlessly be kicked out in RecheckTx
 	wtxs := txmp.store.getAllTxs()
 
 	// Issue CheckTx calls for each remaining transaction, and when all the
 	// rechecks are complete signal watchers that transactions may be available.
-	go func() {
-		g, start := taskgroup.New(nil).Limit(2 * runtime.NumCPU())
-
-		for _, wtx := range wtxs {
-			wtx := wtx
-			start(func() error {
-				// The response for this CheckTx is handled by the default recheckTxCallback.
-				rsp, err := txmp.proxyAppConn.CheckTxSync(abci.RequestCheckTx{
-					Tx:   wtx.tx,
-					Type: abci.CheckTxType_Recheck,
-				})
-				if err != nil {
-					txmp.logger.Error("failed to execute CheckTx during recheck",
-						"err", err, "key", fmt.Sprintf("%x", wtx.key))
-				} else {
-					txmp.handleRecheckResult(wtx, rsp)
-				}
-				return nil
-			})
+	for _, wtx := range wtxs {
+		wtx := wtx
+		// The response for this CheckTx is handled by the default recheckTxCallback.
+		rsp, err := txmp.proxyAppConn.CheckTxSync(abci.RequestCheckTx{
+			Tx:   wtx.tx,
+			Type: abci.CheckTxType_Recheck,
+		})
+		if err != nil {
+			txmp.logger.Error("failed to execute CheckTx during recheck",
+				"err", err, "key", fmt.Sprintf("%x", wtx.key))
+		} else {
+			txmp.handleRecheckResult(wtx, rsp)
 		}
-		_ = txmp.proxyAppConn.FlushAsync()
+	}
+	_ = txmp.proxyAppConn.FlushAsync()
 
-		// When recheck is complete, trigger a notification for more transactions.
-		_ = g.Wait()
-		txmp.notifyTxsAvailable()
-	}()
+	// When recheck is complete, trigger a notification for more transactions.
+	txmp.notifyTxsAvailable()
 }
 
 // availableBytes returns the number of bytes available in the mempool.

mempool/cat/spec.md

@@ -60,7 +60,7 @@ Given this criteria, it is feasible, yet unlikely that a node receives two `Seen
 
 A `SeenTx` MAY be sent for each transaction currently in the transaction pool when a connection with a peer is first established. This acts as a mechanism for syncing pool state across peers.
 
-The `SeenTx` message MUST only be broadcasted after validation and storage. Although it is possible that a node later drops a transaction under load shedding, a `SeenTx` should give as strong guarantees as possible that the node can be relied upon by others that don't yet have the transcation to obtain it.
+The `SeenTx` message MUST only be broadcasted after validation and storage. Although it is possible that a node later drops a transaction under load shedding, a `SeenTx` should give as strong guarantees as possible that the node can be relied upon by others that don't yet have the transaction to obtain it.
 
 > **Note:**
 > Inbound transactions submitted via the RPC do not trigger a `SeenTx` message as it is assumed that the node is the first to see the transaction and by gossiping it to others it is implied that the node has seen the transaction.

mempool/v1/mempool.go

@@ -2,14 +2,11 @@ package v1
 
 import (
 	"fmt"
-	"runtime"
 	"sort"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/creachadair/taskgroup"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/clist"
@@ -650,8 +647,6 @@ func (txmp *TxMempool) insertTx(wtx *WrappedTx) {
 // that case is handled by addNewTransaction instead.
 func (txmp *TxMempool) handleRecheckResult(tx types.Tx, checkTxRes *abci.ResponseCheckTx) {
 	txmp.metrics.RecheckTimes.Add(1)
-	txmp.mtx.Lock()
-	defer txmp.mtx.Unlock()
 
 	// Find the transaction reported by the ABCI callback. It is possible the
 	// transaction was evicted during the recheck, in which case the transaction
@@ -713,34 +708,23 @@ func (txmp *TxMempool) recheckTransactions() {
 
 	// Issue CheckTx calls for each remaining transaction, and when all the
 	// rechecks are complete signal watchers that transactions may be available.
-	go func() {
-		g, start := taskgroup.New(nil).Limit(2 * runtime.NumCPU())
-
-		for _, wtx := range wtxs {
-			wtx := wtx
-			start(func() error {
-				// The response for this CheckTx is handled by the default recheckTxCallback.
-				rsp, err := txmp.proxyAppConn.CheckTxSync(abci.RequestCheckTx{
-					Tx:   wtx.tx,
-					Type: abci.CheckTxType_Recheck,
-				})
-				if err != nil {
-					txmp.logger.Error("failed to execute CheckTx during recheck",
-						"err", err, "hash", fmt.Sprintf("%x", wtx.tx.Hash()))
-				} else {
-					txmp.handleRecheckResult(wtx.tx, rsp)
-				}
-				return nil
-			})
+	for _, wtx := range wtxs {
+		wtx := wtx
+		// The response for this CheckTx is handled by the default recheckTxCallback.
+		rsp, err := txmp.proxyAppConn.CheckTxSync(abci.RequestCheckTx{
+			Tx:   wtx.tx,
+			Type: abci.CheckTxType_Recheck,
+		})
+		if err != nil {
+			txmp.logger.Error("failed to execute CheckTx during recheck",
+				"err", err, "hash", fmt.Sprintf("%x", wtx.tx.Hash()))
+		} else {
+			txmp.handleRecheckResult(wtx.tx, rsp)
 		}
-		_ = txmp.proxyAppConn.FlushAsync()
+	}
+	_ = txmp.proxyAppConn.FlushAsync()
 
-		// When recheck is complete, trigger a notification for more transactions.
-		_ = g.Wait()
-		txmp.mtx.Lock()
-		defer txmp.mtx.Unlock()
-		txmp.notifyTxsAvailable()
-	}()
+	txmp.notifyTxsAvailable()
 }
 
 // canAddTx returns an error if we cannot insert the provided *WrappedTx into

pkg/trace/README.md

@@ -15,7 +15,7 @@ trace_push_batch_size = 1000
 
 # The list of tables that are updated when tracing. All available tables and
 # their schema can be found in the pkg/trace/schema package. It is represented as a
-# comma separate string. For example: "consensus_round_state,mempool_tx".
+# comma separated string. For example: "consensus_round_state,mempool_tx".
 tracing_tables = "consensus_round_state,mempool_tx"
 ```