diff --git a/blockchain/msgs.go b/blocksync/msgs.go
similarity index 99%
rename from blockchain/msgs.go
rename to blocksync/msgs.go
index 35868830b..081cbe4f8 100644
--- a/blockchain/msgs.go
+++ b/blocksync/msgs.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"errors"
@@ -6,7 +6,7 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	"github.com/tendermint/tendermint/types"
 )
 
diff --git a/blockchain/msgs_test.go b/blocksync/msgs_test.go
similarity index 88%
rename from blockchain/msgs_test.go
rename to blocksync/msgs_test.go
index df8efca14..b27376b14 100644
--- a/blockchain/msgs_test.go
+++ b/blocksync/msgs_test.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync_test
 
 import (
 	"encoding/hex"
@@ -9,7 +9,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/blocksync"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -28,7 +29,7 @@ func TestBcBlockRequestMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			request := bcproto.BlockRequest{Height: tc.requestHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&request) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&request) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
@@ -48,14 +49,14 @@ func TestBcNoBlockResponseMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			nonResponse := bcproto.NoBlockResponse{Height: tc.nonResponseHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
 
 func TestBcStatusRequestMessageValidateBasic(t *testing.T) {
 	request := bcproto.StatusRequest{}
-	assert.NoError(t, ValidateMsg(&request))
+	assert.NoError(t, blocksync.ValidateMsg(&request))
 }
 
 func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
@@ -73,7 +74,7 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
 		tc := tc
 		t.Run(tc.testName, func(t *testing.T) {
 			response := bcproto.StatusResponse{Height: tc.responseHeight}
-			assert.Equal(t, tc.expectErr, ValidateMsg(&response) != nil, "Validate Basic had an unexpected result")
+			assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&response) != nil, "Validate Basic had an unexpected result")
 		})
 	}
 }
diff --git a/blockchain/pool.go b/blocksync/pool.go
similarity index 99%
rename from blockchain/pool.go
rename to blocksync/pool.go
index ceab887ad..99dcb79e2 100644
--- a/blockchain/pool.go
+++ b/blocksync/pool.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"errors"
@@ -58,7 +58,7 @@ var peerTimeout = 15 * time.Second // not const so we can override with tests
 	are not at peer limits, we can probably switch to consensus reactor
 */
 
-// BlockPool keeps track of the fast sync peers, block requests and block responses.
+// BlockPool keeps track of the block sync peers, block requests and block responses.
 type BlockPool struct {
 	service.BaseService
 	startTime time.Time
diff --git a/blockchain/pool_test.go b/blocksync/pool_test.go
similarity index 99%
rename from blockchain/pool_test.go
rename to blocksync/pool_test.go
index c67da0afd..9fcc9dde4 100644
--- a/blockchain/pool_test.go
+++ b/blocksync/pool_test.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"
diff --git a/blockchain/reactor.go b/blocksync/reactor.go
similarity index 99%
rename from blockchain/reactor.go
rename to blocksync/reactor.go
index 06a77de4d..7a909c175 100644
--- a/blockchain/reactor.go
+++ b/blocksync/reactor.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"
@@ -7,7 +7,7 @@ import (
 
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
diff --git a/blockchain/reactor_test.go b/blocksync/reactor_test.go
similarity index 99%
rename from blockchain/reactor_test.go
rename to blocksync/reactor_test.go
index db4cbead2..18c8c3059 100644
--- a/blockchain/reactor_test.go
+++ b/blocksync/reactor_test.go
@@ -1,4 +1,4 @@
-package blockchain
+package blocksync
 
 import (
 	"fmt"
diff --git a/config/config.go b/config/config.go
index 9c8c3c236..21cff0b1d 100644
--- a/config/config.go
+++ b/config/config.go
@@ -72,7 +72,7 @@ type Config struct {
 	P2P             *P2PConfig             `mapstructure:"p2p"`
 	Mempool         *MempoolConfig         `mapstructure:"mempool"`
 	StateSync       *StateSyncConfig       `mapstructure:"statesync"`
-	FastSync        *FastSyncConfig        `mapstructure:"fastsync"`
+	BlockSync       *BlockSyncConfig       `mapstructure:"fastsync"`
 	Consensus       *ConsensusConfig       `mapstructure:"consensus"`
 	TxIndex         *TxIndexConfig         `mapstructure:"tx_index"`
 	Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"`
@@ -86,7 +86,7 @@ func DefaultConfig() *Config {
 		P2P:             DefaultP2PConfig(),
 		Mempool:         DefaultMempoolConfig(),
 		StateSync:       DefaultStateSyncConfig(),
-		FastSync:        DefaultFastSyncConfig(),
+		BlockSync:       DefaultBlockSyncConfig(),
 		Consensus:       DefaultConsensusConfig(),
 		TxIndex:         DefaultTxIndexConfig(),
 		Instrumentation: DefaultInstrumentationConfig(),
@@ -101,7 +101,7 @@ func TestConfig() *Config {
 		P2P:             TestP2PConfig(),
 		Mempool:         TestMempoolConfig(),
 		StateSync:       TestStateSyncConfig(),
-		FastSync:        TestFastSyncConfig(),
+		BlockSync:       TestBlockSyncConfig(),
 		Consensus:       TestConsensusConfig(),
 		TxIndex:         TestTxIndexConfig(),
 		Instrumentation: TestInstrumentationConfig(),
@@ -136,7 +136,7 @@ func (cfg *Config) ValidateBasic() error {
 	if err := cfg.StateSync.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [statesync] section: %w", err)
 	}
-	if err := cfg.FastSync.ValidateBasic(); err != nil {
+	if err := cfg.BlockSync.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [fastsync] section: %w", err)
 	}
 	if err := cfg.Consensus.ValidateBasic(); err != nil {
@@ -817,7 +817,7 @@ func DefaultStateSyncConfig() *StateSyncConfig {
 	}
 }
 
-// TestFastSyncConfig returns a default configuration for the state sync service
+// TestStateSyncConfig returns a default configuration for the state sync service
 func TestStateSyncConfig() *StateSyncConfig {
 	return DefaultStateSyncConfig()
 }
@@ -873,34 +873,34 @@ func (cfg *StateSyncConfig) ValidateBasic() error {
 }
 
 //-----------------------------------------------------------------------------
-// FastSyncConfig
+// BlockSyncConfig
 
-// FastSyncConfig defines the configuration for the Tendermint fast sync service
-type FastSyncConfig struct {
+// BlockSyncConfig (formerly known as FastSync) defines the configuration for the Tendermint block sync service
+type BlockSyncConfig struct {
 	Version string `mapstructure:"version"`
 }
 
-// DefaultFastSyncConfig returns a default configuration for the fast sync service
-func DefaultFastSyncConfig() *FastSyncConfig {
-	return &FastSyncConfig{
+// DefaultBlockSyncConfig returns a default configuration for the block sync service
+func DefaultBlockSyncConfig() *BlockSyncConfig {
+	return &BlockSyncConfig{
 		Version: "v0",
 	}
 }
 
-// TestFastSyncConfig returns a default configuration for the fast sync.
-func TestFastSyncConfig() *FastSyncConfig {
-	return DefaultFastSyncConfig()
+// TestBlockSyncConfig returns a default configuration for the block sync.
+func TestBlockSyncConfig() *BlockSyncConfig {
+	return DefaultBlockSyncConfig()
 }
 
 // ValidateBasic performs basic validation.
-func (cfg *FastSyncConfig) ValidateBasic() error {
+func (cfg *BlockSyncConfig) ValidateBasic() error {
 	switch cfg.Version {
 	case "v0":
 		return nil
 	case "v1", "v2":
-		return fmt.Errorf("fast sync version %s has been deprecated. Please use v0 instead", cfg.Version)
+		return fmt.Errorf("blocksync version %s has been deprecated. Please use v0 instead", cfg.Version)
 	default:
-		return fmt.Errorf("unknown fastsync version %s", cfg.Version)
+		return fmt.Errorf("unknown blocksync version %s", cfg.Version)
 	}
 }
 
diff --git a/config/config_test.go b/config/config_test.go
index cdcddf427..2446f08e6 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -128,8 +128,8 @@ func TestStateSyncConfigValidateBasic(t *testing.T) {
 	require.NoError(t, cfg.ValidateBasic())
 }
 
-func TestFastSyncConfigValidateBasic(t *testing.T) {
-	cfg := TestFastSyncConfig()
+func TestBlockSyncConfigValidateBasic(t *testing.T) {
+	cfg := TestBlockSyncConfig()
 	assert.NoError(t, cfg.ValidateBasic())
 
 	// tamper with version
diff --git a/config/toml.go b/config/toml.go
index a0112351d..02120ed4b 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -429,13 +429,13 @@ chunk_request_timeout = "{{ .StateSync.ChunkRequestTimeout }}"
 chunk_fetchers = "{{ .StateSync.ChunkFetchers }}"
 
 #######################################################
-###       Fast Sync Configuration Connections       ###
+###       Block Sync Configuration Connections       ###
 #######################################################
 [fastsync]
 
-# Fast Sync version to use:
+# Block Sync version to use:
 # 
-# In v0.37, v1 and v2 of the fast sync protocol were deprecated.
+# In v0.37, v1 and v2 of the block sync protocols were deprecated.
 # Please use v0 instead.
 #
 #   1) "v0" - the default fast sync implementation
diff --git a/docs/tendermint-core/README.md b/docs/tendermint-core/README.md
index fa94f3a1e..60f995204 100644
--- a/docs/tendermint-core/README.md
+++ b/docs/tendermint-core/README.md
@@ -17,7 +17,7 @@ This section dives into the internals of Tendermint the implementation.
 - [Subscribing to events](./subscription.md)
 - [Block Structure](./block-structure.md)
 - [RPC](./rpc.md)
-- [Fast Sync](./fast-sync.md)
+- [Block Sync](./block-sync.md)
 - [State Sync](./state-sync.md)
 - [Mempool](./mempool.md)
 - [Light Client](./light-client.md)
diff --git a/docs/tendermint-core/block-sync.md b/docs/tendermint-core/block-sync.md
new file mode 100644
index 000000000..4a2843a59
--- /dev/null
+++ b/docs/tendermint-core/block-sync.md
@@ -0,0 +1,89 @@
+---
+order: 10
+---
+
+# Block Sync
+*Formerly known as Fast Sync*
+
+In a proof of work blockchain, syncing with the chain is the same
+process as staying up-to-date with the consensus: download blocks, and
+look for the one with the most total work. In proof-of-stake, the
+consensus process is more complex, as it involves rounds of
+communication between the nodes to determine what block should be
+committed next. Using this process to sync up with the blockchain from
+scratch can take a very long time. It's much faster to just download
+blocks and check the merkle tree of validators than to run the real-time
+consensus gossip protocol.
+
+## Using Block Sync
+
+To support faster syncing, Tendermint offers a `fast-sync` mode, which
+is enabled by default, and can be toggled in the `config.toml` or via
+`--fast_sync=false`.
+
+In this mode, the Tendermint daemon will sync hundreds of times faster
+than if it used the real-time consensus process. Once caught up, the
+daemon will switch out of Block Sync and into the normal consensus mode.
+After running for some time, the node is considered `caught up` if it
+has at least one peer and it's height is at least as high as the max
+reported peer height. See [the IsCaughtUp
+method](https://github.com/tendermint/tendermint/blob/b467515719e686e4678e6da4e102f32a491b85a0/blockchain/pool.go#L128).
+
+<<<<<<< HEAD:docs/tendermint-core/fast-sync.md
+Note: There are three versions of fast sync. We recommend using v0 as v1 and v2 are still in beta. 
+||||||| parent of 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/fast-sync.md
+Note: There are three versions of fast sync. We recommend using v0 as v2 is still in beta.
+=======
+Note: There are two versions of Block Sync. We recommend using v0 as v2 is still in beta.
+>>>>>>> 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/block-sync.md
+  If you would like to use a different version you can do so by changing the version in the `config.toml`:
+
+```toml
+#######################################################
+###       Block Sync Configuration Connections       ###
+#######################################################
+[fastsync]
+
+<<<<<<< HEAD:docs/tendermint-core/fast-sync.md
+# Fast Sync version to use:
+#   1) "v0" (default) - the legacy fast sync implementation
+#   2) "v1" - refactor of v0 version for better testability
+#   2) "v2" - complete redesign of v0, optimized for testability & readability 
+||||||| parent of 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/fast-sync.md
+# Fast Sync version to use:
+#   1) "v0" (default) - the legacy fast sync implementation
+#   2) "v2" - complete redesign of v0, optimized for testability & readability
+=======
+# Block Sync version to use:
+#   1) "v0" (default) - the legacy Block Sync implementation
+#   2) "v2" - complete redesign of v0, optimized for testability & readability
+>>>>>>> 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/block-sync.md
+version = "v0"
+```
+
+If we're lagging sufficiently, we should go back to block syncing, but
+this is an [open issue](https://github.com/tendermint/tendermint/issues/129).
+<<<<<<< HEAD:docs/tendermint-core/fast-sync.md
+||||||| parent of 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/fast-sync.md
+
+## The Fast Sync event
+When the tendermint blockchain core launches, it might switch to the `fast-sync`
+mode to catch up the states to the current network best height. the core will emits
+a fast-sync event to expose the current status and the sync height. Once it catched
+the network best height, it will switches to the state sync mechanism and then emit
+another event for exposing the fast-sync `complete` status and the state `height`.
+
+The user can query the events by subscribing `EventQueryFastSyncStatus`
+Please check [types](https://pkg.go.dev/github.com/tendermint/tendermint/types?utm_source=godoc#pkg-constants) for the details.
+=======
+
+## The Block Sync event
+When the tendermint blockchain core launches, it might switch to the `block-sync`
+mode to catch up the states to the current network best height. the core will emits
+a fast-sync event to expose the current status and the sync height. Once it catched
+the network best height, it will switches to the state sync mechanism and then emit
+another event for exposing the fast-sync `complete` status and the state `height`.
+
+The user can query the events by subscribing `EventQueryBlockSyncStatus`
+Please check [types](https://pkg.go.dev/github.com/tendermint/tendermint/types?utm_source=godoc#pkg-constants) for the details.
+>>>>>>> 6ff4c3139 (blockchain: rename to blocksync service (#6755)):docs/tendermint-core/block-sync.md
diff --git a/docs/tendermint-core/fast-sync.md b/docs/tendermint-core/fast-sync.md
deleted file mode 100644
index 9bbeade38..000000000
--- a/docs/tendermint-core/fast-sync.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-order: 10
----
-
-# Fast Sync
-
-In a proof of work blockchain, syncing with the chain is the same
-process as staying up-to-date with the consensus: download blocks, and
-look for the one with the most total work. In proof-of-stake, the
-consensus process is more complex, as it involves rounds of
-communication between the nodes to determine what block should be
-committed next. Using this process to sync up with the blockchain from
-scratch can take a very long time. It's much faster to just download
-blocks and check the merkle tree of validators than to run the real-time
-consensus gossip protocol.
-
-## Using Fast Sync
-
-To support faster syncing, Tendermint offers a `fast-sync` mode, which
-is enabled by default, and can be toggled in the `config.toml` or via
-`--fast_sync=false`.
-
-In this mode, the Tendermint daemon will sync hundreds of times faster
-than if it used the real-time consensus process. Once caught up, the
-daemon will switch out of fast sync and into the normal consensus mode.
-After running for some time, the node is considered `caught up` if it
-has at least one peer and it's height is at least as high as the max
-reported peer height. See [the IsCaughtUp
-method](https://github.com/tendermint/tendermint/blob/b467515719e686e4678e6da4e102f32a491b85a0/blockchain/pool.go#L128).
-
-Note: There are three versions of fast sync. We recommend using v0 as v1 and v2 are still in beta. 
-  If you would like to use a different version you can do so by changing the version in the `config.toml`:
-
-```toml
-#######################################################
-###       Fast Sync Configuration Connections       ###
-#######################################################
-[fastsync]
-
-# Fast Sync version to use:
-#   1) "v0" (default) - the legacy fast sync implementation
-#   2) "v1" - refactor of v0 version for better testability
-#   2) "v2" - complete redesign of v0, optimized for testability & readability 
-version = "v0"
-```
-
-If we're lagging sufficiently, we should go back to fast syncing, but
-this is an [open issue](https://github.com/tendermint/tendermint/issues/129).
diff --git a/docs/tendermint-core/state-sync.md b/docs/tendermint-core/state-sync.md
index a6e314fe5..8400a6ef9 100644
--- a/docs/tendermint-core/state-sync.md
+++ b/docs/tendermint-core/state-sync.md
@@ -4,7 +4,7 @@ order: 11
 
 # State Sync
 
-With fast sync a node is downloading all of the data of an application from genesis and verifying it. 
+With block sync a node is downloading all of the data of an application from genesis and verifying it. 
 With state sync your node will download data related to the head or near the head of the chain and verify the data. 
 This leads to drastically shorter times for joining a network. 
 
diff --git a/node/node.go b/node/node.go
index 51fe490d8..ac61dbcbd 100644
--- a/node/node.go
+++ b/node/node.go
@@ -212,7 +212,7 @@ type Node struct {
 	eventBus          *types.EventBus // pub/sub for services
 	stateStore        sm.Store
 	blockStore        *store.BlockStore // store the blockchain to disk
-	bcReactor         p2p.Reactor       // for fast-syncing
+	bcReactor         p2p.Reactor       // for block-syncing
 	mempoolReactor    p2p.Reactor       // for gossipping transactions
 	mempool           mempl.Mempool
 	stateSync         bool                    // whether the node should state sync on startup
@@ -783,9 +783,9 @@ func NewNode(config *cfg.Config,
 		}
 	}
 
-	// Determine whether we should do fast sync. This must happen after the handshake, since the
+	// Determine whether we should do block sync. This must happen after the handshake, since the
 	// app may modify the validator set, specifying ourself as the only validator.
-	fastSync := config.FastSyncMode && !onlyValidatorIsUs(state, pubKey)
+	blockSync := config.FastSyncMode && !onlyValidatorIsUs(state, pubKey)
 
 	logNodeStartupInfo(state, pubKey, logger, consensusLogger)
 
@@ -809,17 +809,17 @@ func NewNode(config *cfg.Config,
 	)
 
 	// Make BlockchainReactor. Don't start fast sync if we're doing a state sync first.
-	bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, fastSync && !stateSync, logger)
+	bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, blockSync && !stateSync, logger)
 	if err != nil {
 		return nil, fmt.Errorf("could not create blockchain reactor: %w", err)
 	}
 
-	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or fast sync first.
+	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first.
 	// FIXME We need to update metrics here, since other reactors don't have access to them.
 	if stateSync {
 		csMetrics.StateSyncing.Set(1)
-	} else if fastSync {
-		csMetrics.FastSyncing.Set(1)
+	} else if blockSync {
+		csMetrics.BlockSyncing.Set(1)
 	}
 	consensusReactor, consensusState := createConsensusReactor(
 		config, state, blockExec, blockStore, mempool, evidencePool,
@@ -827,7 +827,7 @@ func NewNode(config *cfg.Config,
 	)
 
 	// Set up state sync reactor, and schedule a sync if requested.
-	// FIXME The way we do phased startups (e.g. replay -> fast sync -> consensus) is very messy,
+	// FIXME The way we do phased startups (e.g. replay -> block sync -> consensus) is very messy,
 	// we should clean this whole thing up. See:
 	// https://github.com/tendermint/tendermint/issues/4644
 	stateSyncReactor := statesync.NewReactor(
@@ -982,7 +982,7 @@ func (n *Node) OnStart() error {
 
 	// Run state sync
 	if n.stateSync {
-		bcR, ok := n.bcReactor.(fastSyncReactor)
+		bcR, ok := n.bcReactor.(blockSyncReactor)
 		if !ok {
 			return fmt.Errorf("this blockchain reactor does not support switching from state sync")
 		}
diff --git a/proto/tendermint/blocksync/message_test.go b/proto/tendermint/blocksync/message_test.go
new file mode 100644
index 000000000..b8044df80
--- /dev/null
+++ b/proto/tendermint/blocksync/message_test.go
@@ -0,0 +1,131 @@
+<<<<<<<< HEAD:blockchain/msgs_test.go
+package blockchain
+|||||||| parent of 6ff4c3139 (blockchain: rename to blocksync service (#6755)):proto/tendermint/blockchain/message_test.go
+package blockchain_test
+========
+package blocksync_test
+>>>>>>>> 6ff4c3139 (blockchain: rename to blocksync service (#6755)):proto/tendermint/blocksync/message_test.go
+
+import (
+	"encoding/hex"
+	"math"
+	"testing"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
+	"github.com/tendermint/tendermint/types"
+)
+
+func TestBcBlockRequestMessageValidateBasic(t *testing.T) {
+	testCases := []struct {
+		testName      string
+		requestHeight int64
+		expectErr     bool
+	}{
+		{"Valid Request Message", 0, false},
+		{"Valid Request Message", 1, false},
+		{"Invalid Request Message", -1, true},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.testName, func(t *testing.T) {
+			request := bcproto.BlockRequest{Height: tc.requestHeight}
+			assert.Equal(t, tc.expectErr, ValidateMsg(&request) != nil, "Validate Basic had an unexpected result")
+		})
+	}
+}
+
+func TestBcNoBlockResponseMessageValidateBasic(t *testing.T) {
+	testCases := []struct {
+		testName          string
+		nonResponseHeight int64
+		expectErr         bool
+	}{
+		{"Valid Non-Response Message", 0, false},
+		{"Valid Non-Response Message", 1, false},
+		{"Invalid Non-Response Message", -1, true},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.testName, func(t *testing.T) {
+			nonResponse := bcproto.NoBlockResponse{Height: tc.nonResponseHeight}
+			assert.Equal(t, tc.expectErr, ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result")
+		})
+	}
+}
+
+func TestBcStatusRequestMessageValidateBasic(t *testing.T) {
+	request := bcproto.StatusRequest{}
+	assert.NoError(t, ValidateMsg(&request))
+}
+
+func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
+	testCases := []struct {
+		testName       string
+		responseHeight int64
+		expectErr      bool
+	}{
+		{"Valid Response Message", 0, false},
+		{"Valid Response Message", 1, false},
+		{"Invalid Response Message", -1, true},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.testName, func(t *testing.T) {
+			response := bcproto.StatusResponse{Height: tc.responseHeight}
+			assert.Equal(t, tc.expectErr, ValidateMsg(&response) != nil, "Validate Basic had an unexpected result")
+		})
+	}
+}
+
+// nolint:lll // ignore line length in tests
+func TestBlockchainMessageVectors(t *testing.T) {
+	block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil)
+	block.Version.Block = 11 // overwrite updated protocol version
+
+	bpb, err := block.ToProto()
+	require.NoError(t, err)
+
+	testCases := []struct {
+		testName string
+		bmsg     proto.Message
+		expBytes string
+	}{
+		{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
+			BlockRequest: &bcproto.BlockRequest{Height: 1}}}, "0a020801"},
+		{"BlockRequestMessage", &bcproto.Message{Sum: &bcproto.Message_BlockRequest{
+			BlockRequest: &bcproto.BlockRequest{Height: math.MaxInt64}}},
+			"0a0a08ffffffffffffffff7f"},
+		{"BlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_BlockResponse{
+			BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, "1a700a6e0a5b0a02080b1803220b088092b8c398feffffff012a0212003a20c4da88e876062aa1543400d50d0eaa0dac88096057949cfb7bca7f3a48c04bf96a20e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855120d0a0b48656c6c6f20576f726c641a00"},
+		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
+			NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, "12020801"},
+		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
+			NoBlockResponse: &bcproto.NoBlockResponse{Height: math.MaxInt64}}},
+			"120a08ffffffffffffffff7f"},
+		{"StatusRequestMessage", &bcproto.Message{Sum: &bcproto.Message_StatusRequest{
+			StatusRequest: &bcproto.StatusRequest{}}},
+			"2200"},
+		{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
+			StatusResponse: &bcproto.StatusResponse{Height: 1, Base: 2}}},
+			"2a0408011002"},
+		{"StatusResponseMessage", &bcproto.Message{Sum: &bcproto.Message_StatusResponse{
+			StatusResponse: &bcproto.StatusResponse{Height: math.MaxInt64, Base: math.MaxInt64}}},
+			"2a1408ffffffffffffffff7f10ffffffffffffffff7f"},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.testName, func(t *testing.T) {
+			bz, _ := proto.Marshal(tc.bmsg)
+
+			require.Equal(t, tc.expBytes, hex.EncodeToString(bz))
+		})
+	}
+}
diff --git a/proto/tendermint/blockchain/types.pb.go b/proto/tendermint/blocksync/types.pb.go
similarity index 90%
rename from proto/tendermint/blockchain/types.pb.go
rename to proto/tendermint/blocksync/types.pb.go
index bc160b230..fcbef7107 100644
--- a/proto/tendermint/blockchain/types.pb.go
+++ b/proto/tendermint/blocksync/types.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tendermint/blockchain/types.proto
+// source: tendermint/blocksync/types.proto
 
-package blockchain
+package blocksync
 
 import (
 	fmt "fmt"
@@ -32,7 +32,7 @@ func (m *BlockRequest) Reset()         { *m = BlockRequest{} }
 func (m *BlockRequest) String() string { return proto.CompactTextString(m) }
 func (*BlockRequest) ProtoMessage()    {}
 func (*BlockRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{0}
+	return fileDescriptor_19b397c236e0fa07, []int{0}
 }
 func (m *BlockRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -77,7 +77,7 @@ func (m *NoBlockResponse) Reset()         { *m = NoBlockResponse{} }
 func (m *NoBlockResponse) String() string { return proto.CompactTextString(m) }
 func (*NoBlockResponse) ProtoMessage()    {}
 func (*NoBlockResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{1}
+	return fileDescriptor_19b397c236e0fa07, []int{1}
 }
 func (m *NoBlockResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -122,7 +122,7 @@ func (m *BlockResponse) Reset()         { *m = BlockResponse{} }
 func (m *BlockResponse) String() string { return proto.CompactTextString(m) }
 func (*BlockResponse) ProtoMessage()    {}
 func (*BlockResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{2}
+	return fileDescriptor_19b397c236e0fa07, []int{2}
 }
 func (m *BlockResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -166,7 +166,7 @@ func (m *StatusRequest) Reset()         { *m = StatusRequest{} }
 func (m *StatusRequest) String() string { return proto.CompactTextString(m) }
 func (*StatusRequest) ProtoMessage()    {}
 func (*StatusRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{3}
+	return fileDescriptor_19b397c236e0fa07, []int{3}
 }
 func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -205,7 +205,7 @@ func (m *StatusResponse) Reset()         { *m = StatusResponse{} }
 func (m *StatusResponse) String() string { return proto.CompactTextString(m) }
 func (*StatusResponse) ProtoMessage()    {}
 func (*StatusResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{4}
+	return fileDescriptor_19b397c236e0fa07, []int{4}
 }
 func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -262,7 +262,7 @@ func (m *Message) Reset()         { *m = Message{} }
 func (m *Message) String() string { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()    {}
 func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2927480384e78499, []int{5}
+	return fileDescriptor_19b397c236e0fa07, []int{5}
 }
 func (m *Message) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -373,42 +373,41 @@ func (*Message) XXX_OneofWrappers() []interface{} {
 }
 
 func init() {
-	proto.RegisterType((*BlockRequest)(nil), "tendermint.blockchain.BlockRequest")
-	proto.RegisterType((*NoBlockResponse)(nil), "tendermint.blockchain.NoBlockResponse")
-	proto.RegisterType((*BlockResponse)(nil), "tendermint.blockchain.BlockResponse")
-	proto.RegisterType((*StatusRequest)(nil), "tendermint.blockchain.StatusRequest")
-	proto.RegisterType((*StatusResponse)(nil), "tendermint.blockchain.StatusResponse")
-	proto.RegisterType((*Message)(nil), "tendermint.blockchain.Message")
+	proto.RegisterType((*BlockRequest)(nil), "tendermint.blocksync.BlockRequest")
+	proto.RegisterType((*NoBlockResponse)(nil), "tendermint.blocksync.NoBlockResponse")
+	proto.RegisterType((*BlockResponse)(nil), "tendermint.blocksync.BlockResponse")
+	proto.RegisterType((*StatusRequest)(nil), "tendermint.blocksync.StatusRequest")
+	proto.RegisterType((*StatusResponse)(nil), "tendermint.blocksync.StatusResponse")
+	proto.RegisterType((*Message)(nil), "tendermint.blocksync.Message")
 }
 
-func init() { proto.RegisterFile("tendermint/blockchain/types.proto", fileDescriptor_2927480384e78499) }
+func init() { proto.RegisterFile("tendermint/blocksync/types.proto", fileDescriptor_19b397c236e0fa07) }
 
-var fileDescriptor_2927480384e78499 = []byte{
-	// 370 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xc1, 0x4e, 0xfa, 0x40,
-	0x10, 0xc6, 0xdb, 0x7f, 0x81, 0x7f, 0x32, 0x50, 0x1a, 0x9b, 0xa8, 0xc4, 0x98, 0x46, 0xab, 0x12,
-	0x3d, 0xd8, 0x26, 0x78, 0x25, 0x1e, 0x38, 0x11, 0x13, 0x8c, 0xa9, 0xc6, 0x83, 0x17, 0xd2, 0xe2,
-	0x86, 0x36, 0x4a, 0x17, 0xd9, 0xed, 0xc1, 0xb7, 0xf0, 0x19, 0x7c, 0x1a, 0x8f, 0x1c, 0x3d, 0x1a,
-	0x78, 0x11, 0xc3, 0x6c, 0x29, 0x4b, 0x03, 0xf5, 0xb6, 0x3b, 0xfd, 0xe6, 0x37, 0xdf, 0x7e, 0x99,
-	0xc2, 0x31, 0x27, 0xf1, 0x33, 0x99, 0x8c, 0xa2, 0x98, 0xbb, 0xc1, 0x2b, 0x1d, 0xbc, 0x0c, 0x42,
-	0x3f, 0x8a, 0x5d, 0xfe, 0x3e, 0x26, 0xcc, 0x19, 0x4f, 0x28, 0xa7, 0xe6, 0xee, 0x4a, 0xe2, 0xac,
-	0x24, 0x07, 0x87, 0x52, 0x27, 0xca, 0x45, 0xbf, 0x68, 0xb2, 0x9b, 0x50, 0xeb, 0x2c, 0xae, 0x1e,
-	0x79, 0x4b, 0x08, 0xe3, 0xe6, 0x1e, 0x54, 0x42, 0x12, 0x0d, 0x43, 0xde, 0x50, 0x8f, 0xd4, 0x73,
-	0xcd, 0x4b, 0x6f, 0xf6, 0x05, 0x18, 0xb7, 0x34, 0x55, 0xb2, 0x31, 0x8d, 0x19, 0xd9, 0x2a, 0xbd,
-	0x06, 0x7d, 0x5d, 0x78, 0x09, 0x65, 0x1c, 0x89, 0xba, 0x6a, 0x6b, 0xdf, 0x91, 0x8c, 0x8a, 0x07,
-	0x08, 0xbd, 0x50, 0xd9, 0x06, 0xe8, 0xf7, 0xdc, 0xe7, 0x09, 0x4b, 0x3d, 0xd9, 0x6d, 0xa8, 0x2f,
-	0x0b, 0xc5, 0xa3, 0x4d, 0x13, 0x4a, 0x81, 0xcf, 0x48, 0xe3, 0x1f, 0x56, 0xf1, 0x6c, 0x7f, 0x6a,
-	0xf0, 0xbf, 0x47, 0x18, 0xf3, 0x87, 0xc4, 0xbc, 0x01, 0x1d, 0x67, 0xf4, 0x27, 0x02, 0x9d, 0x3a,
-	0x3a, 0x71, 0x36, 0x46, 0xe7, 0xc8, 0xc9, 0x74, 0x15, 0xaf, 0x16, 0xc8, 0x49, 0x3d, 0xc0, 0x4e,
-	0x4c, 0xfb, 0x4b, 0x9c, 0x30, 0x86, 0x83, 0xab, 0xad, 0xe6, 0x16, 0x5e, 0x2e, 0xc1, 0xae, 0xe2,
-	0x19, 0x71, 0x2e, 0xd4, 0x1e, 0xd4, 0x73, 0x48, 0x0d, 0x91, 0xa7, 0xc5, 0x16, 0x33, 0xa0, 0x1e,
-	0xe4, 0x71, 0x0c, 0xa3, 0xcb, 0x5e, 0x5c, 0x2a, 0xc4, 0xad, 0x05, 0xbf, 0xc0, 0x31, 0xb9, 0x60,
-	0xde, 0x81, 0x91, 0xe1, 0x52, 0x7b, 0x65, 0xe4, 0x9d, 0xfd, 0xc1, 0xcb, 0xfc, 0xd5, 0xd9, 0x5a,
-	0xa5, 0x53, 0x06, 0x8d, 0x25, 0xa3, 0xce, 0xe3, 0xd7, 0xcc, 0x52, 0xa7, 0x33, 0x4b, 0xfd, 0x99,
-	0x59, 0xea, 0xc7, 0xdc, 0x52, 0xa6, 0x73, 0x4b, 0xf9, 0x9e, 0x5b, 0xca, 0x53, 0x7b, 0x18, 0xf1,
-	0x30, 0x09, 0x9c, 0x01, 0x1d, 0xb9, 0xf2, 0x26, 0xaf, 0x8e, 0xb8, 0xc8, 0xee, 0xc6, 0xff, 0x23,
-	0xa8, 0xe0, 0xc7, 0xab, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5e, 0x59, 0x07, 0xbd, 0x3f, 0x03,
-	0x00, 0x00,
+var fileDescriptor_19b397c236e0fa07 = []byte{
+	// 368 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4d, 0x4f, 0xfa, 0x40,
+	0x10, 0xc6, 0xdb, 0x7f, 0x81, 0x7f, 0x32, 0x50, 0x1a, 0x1b, 0xa3, 0xc4, 0x98, 0x86, 0xd4, 0x97,
+	0xe8, 0xc1, 0x36, 0xc1, 0xa3, 0xc6, 0x03, 0x27, 0x4c, 0x7c, 0x49, 0x4a, 0xbc, 0x78, 0x21, 0x14,
+	0x37, 0x40, 0x94, 0x2e, 0x32, 0xdb, 0x03, 0xdf, 0xc2, 0x2f, 0xe0, 0xf7, 0xf1, 0xc8, 0xd1, 0xa3,
+	0x81, 0x2f, 0x62, 0x98, 0x2d, 0x65, 0x69, 0xb0, 0xb7, 0xdd, 0xe9, 0x33, 0xbf, 0x79, 0xfa, 0x64,
+	0x16, 0xea, 0x82, 0x45, 0x2f, 0x6c, 0x32, 0x1a, 0x46, 0xc2, 0x0f, 0xdf, 0x78, 0xef, 0x15, 0xa7,
+	0x51, 0xcf, 0x17, 0xd3, 0x31, 0x43, 0x6f, 0x3c, 0xe1, 0x82, 0xdb, 0xbb, 0x6b, 0x85, 0x97, 0x2a,
+	0x0e, 0x0e, 0x95, 0x3e, 0x52, 0xcb, 0x6e, 0xd9, 0xe3, 0x9e, 0x42, 0xa5, 0xb9, 0xbc, 0x06, 0xec,
+	0x3d, 0x66, 0x28, 0xec, 0x3d, 0x28, 0x0d, 0xd8, 0xb0, 0x3f, 0x10, 0x35, 0xbd, 0xae, 0x9f, 0x19,
+	0x41, 0x72, 0x73, 0xcf, 0xc1, 0x7a, 0xe0, 0x89, 0x12, 0xc7, 0x3c, 0x42, 0xf6, 0xa7, 0xf4, 0x06,
+	0xcc, 0x4d, 0xe1, 0x05, 0x14, 0x69, 0x24, 0xe9, 0xca, 0x8d, 0x7d, 0x4f, 0xf1, 0x29, 0xfd, 0x4b,
+	0xbd, 0x54, 0xb9, 0x16, 0x98, 0x6d, 0xd1, 0x15, 0x31, 0x26, 0x9e, 0xdc, 0x6b, 0xa8, 0xae, 0x0a,
+	0xf9, 0xa3, 0x6d, 0x1b, 0x0a, 0x61, 0x17, 0x59, 0xed, 0x1f, 0x55, 0xe9, 0xec, 0x7e, 0x1a, 0xf0,
+	0xff, 0x9e, 0x21, 0x76, 0xfb, 0xcc, 0xbe, 0x05, 0x93, 0x66, 0x74, 0x26, 0x12, 0x9d, 0x38, 0x72,
+	0xbd, 0x6d, 0xc9, 0x79, 0x6a, 0x30, 0x2d, 0x2d, 0xa8, 0x84, 0x6a, 0x50, 0x6d, 0xd8, 0x89, 0x78,
+	0x67, 0x45, 0x93, 0xbe, 0x68, 0x6e, 0xb9, 0x71, 0xb2, 0x1d, 0x97, 0xc9, 0xaf, 0xa5, 0x05, 0x56,
+	0x94, 0x89, 0xf4, 0x0e, 0xaa, 0x19, 0xa2, 0x41, 0xc4, 0xa3, 0x5c, 0x83, 0x29, 0xcf, 0x0c, 0xb3,
+	0x34, 0xa4, 0xdc, 0xd2, 0xdf, 0x2d, 0xe4, 0xd1, 0x36, 0x42, 0x5f, 0xd2, 0x50, 0x2d, 0xd8, 0x8f,
+	0x60, 0xa5, 0xb4, 0xc4, 0x5c, 0x91, 0x70, 0xc7, 0xf9, 0xb8, 0xd4, 0x5d, 0x15, 0x37, 0x2a, 0xcd,
+	0x22, 0x18, 0x18, 0x8f, 0x9a, 0x4f, 0x5f, 0x73, 0x47, 0x9f, 0xcd, 0x1d, 0xfd, 0x67, 0xee, 0xe8,
+	0x1f, 0x0b, 0x47, 0x9b, 0x2d, 0x1c, 0xed, 0x7b, 0xe1, 0x68, 0xcf, 0x57, 0xfd, 0xa1, 0x18, 0xc4,
+	0xa1, 0xd7, 0xe3, 0x23, 0x5f, 0x5d, 0xe2, 0xf5, 0x91, 0x76, 0xd8, 0xdf, 0xf6, 0x30, 0xc2, 0x12,
+	0x7d, 0xbb, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x1c, 0xa3, 0x45, 0x37, 0x03, 0x00, 0x00,
 }
 
 func (m *BlockRequest) Marshal() (dAtA []byte, err error) {
diff --git a/proto/tendermint/blockchain/types.proto b/proto/tendermint/blocksync/types.proto
similarity index 94%
rename from proto/tendermint/blockchain/types.proto
rename to proto/tendermint/blocksync/types.proto
index f5c143cf5..8c187c793 100644
--- a/proto/tendermint/blockchain/types.proto
+++ b/proto/tendermint/blocksync/types.proto
@@ -1,7 +1,7 @@
 syntax = "proto3";
-package tendermint.blockchain;
+package tendermint.blocksync;
 
-option go_package = "github.com/tendermint/tendermint/proto/tendermint/blockchain";
+option go_package = "github.com/tendermint/tendermint/proto/tendermint/blocksync";
 
 import "tendermint/types/block.proto";
 
diff --git a/rpc/core/env.go b/rpc/core/env.go
index 11a51bfe7..792c60a69 100644
--- a/rpc/core/env.go
+++ b/rpc/core/env.go
@@ -93,6 +93,7 @@ type Environment struct {
 	ConsensusReactor *consensus.Reactor
 	EventBus         *types.EventBus // thread safe
 	Mempool          mempl.Mempool
+	BlockSyncReactor consensus.BlockSyncReactor
 
 	Logger log.Logger
 
diff --git a/test/e2e/README.md b/test/e2e/README.md
index 4f89d2885..70a63dac5 100644
--- a/test/e2e/README.md
+++ b/test/e2e/README.md
@@ -160,4 +160,4 @@ tendermint start
 ./build/node ./node.socket.toml
 ```
 
-Check `node/config.go` to see how the settings of the test application can be tweaked.
\ No newline at end of file
+Check `node/config.go` to see how the settings of the test application can be tweaked.
diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index e203e4d6b..684acb426 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -28,7 +28,7 @@ var (
 	// FIXME: grpc disabled due to https://github.com/tendermint/tendermint/issues/5439
 	nodeABCIProtocols     = uniformChoice{"unix", "tcp", "builtin"} // "grpc"
 	nodePrivvalProtocols  = uniformChoice{"file", "unix", "tcp"}
-	nodeFastSyncs         = uniformChoice{false, true}
+	nodeBlockSyncs        = uniformChoice{"v0"} // "v2"
 	nodeStateSyncs        = uniformChoice{false, true}
 	nodeMempools          = uniformChoice{"v0", "v1"}
 	nodePersistIntervals  = uniformChoice{0, 1, 5}
@@ -201,7 +201,7 @@ func generateNode(
 		StartAt:          startAt,
 		Database:         nodeDatabases.Choose(r).(string),
 		PrivvalProtocol:  nodePrivvalProtocols.Choose(r).(string),
-		FastSync:         nodeFastSyncs.Choose(r).(bool),
+		BlockSync:        nodeBlockSyncs.Choose(r).(string),
 		Mempool:          nodeMempools.Choose(r).(string),
 		StateSync:        nodeStateSyncs.Choose(r).(bool) && startAt > 0,
 		PersistInterval:  ptrUint64(uint64(nodePersistIntervals.Choose(r).(int))),
diff --git a/test/e2e/networks/ci.toml b/test/e2e/networks/ci.toml
index 1fff574ca..8ff028cb1 100644
--- a/test/e2e/networks/ci.toml
+++ b/test/e2e/networks/ci.toml
@@ -63,6 +63,7 @@ abci_protocol = "builtin"
 perturb = ["pause"]
 
 [node.validator05]
+block_sync = "v0" 
 start_at = 1005 # Becomes part of the validator set at 1010
 seeds = ["seed02"]
 database = "cleveldb"
@@ -76,7 +77,7 @@ perturb = ["kill", "pause", "disconnect", "restart"]
 [node.full01]
 start_at = 1010
 mode = "full"
-fast_sync = true
+block_sync = "v0"
 persistent_peers = ["validator01", "validator02", "validator03", "validator04", "validator05"]
 retain_blocks = 1
 perturb = ["restart"]
@@ -84,7 +85,7 @@ perturb = ["restart"]
 [node.full02]
 start_at = 1015
 mode = "full"
-fast_sync = true
+block_sync = "v0"
 state_sync = true
 seeds = ["seed01"]
 perturb = ["restart"]
@@ -97,4 +98,4 @@ persistent_peers = ["validator01", "validator02", "validator03"]
 [node.light02]
 mode= "light"
 start_at= 1015
-persistent_peers = ["validator04", "full01", "validator05"]
\ No newline at end of file
+persistent_peers = ["validator04", "full01", "validator05"]
diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go
index 44c8e9118..6099ab492 100644
--- a/test/e2e/pkg/manifest.go
+++ b/test/e2e/pkg/manifest.go
@@ -88,8 +88,9 @@ type ManifestNode struct {
 	// runner will wait for the network to reach at least this block height.
 	StartAt int64 `toml:"start_at"`
 
-	// FastSync specifies whether to enable the fast sync protocol.
-	FastSync bool `toml:"fast_sync"`
+	// BlockSync specifies the block sync mode: "" (disable), "v0" or "v2".
+	// Defaults to disabled.
+	BlockSync string `toml:"block_sync"`
 
 	// Mempool specifies which version of mempool to use. Either "v0" or "v1"
 	// This defaults to v0.
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index 1123c26a9..6589dbcfe 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -72,7 +72,7 @@ type Node struct {
 	IP               net.IP
 	ProxyPort        uint32
 	StartAt          int64
-	FastSync         bool
+	BlockSync        string
 	StateSync        bool
 	Mempool          string
 	Database         string
@@ -155,7 +155,7 @@ func LoadTestnet(file string) (*Testnet, error) {
 			ABCIProtocol:     Protocol(testnet.ABCIProtocol),
 			PrivvalProtocol:  ProtocolFile,
 			StartAt:          nodeManifest.StartAt,
-			FastSync:         nodeManifest.FastSync,
+			BlockSync:        nodeManifest.BlockSync,
 			Mempool:          nodeManifest.Mempool,
 			StateSync:        nodeManifest.StateSync,
 			PersistInterval:  1,
@@ -297,6 +297,11 @@ func (n Node) Validate(testnet Testnet) error {
 			}
 		}
 	}
+	switch n.BlockSync {
+	case "v0":
+	default:
+		return fmt.Errorf("invalid block sync setting %q", n.BlockSync)
+	}
 	switch n.Mempool {
 	case "", "v0", "v1":
 	default:
diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go
index 2dd84eaf2..022e0209d 100644
--- a/test/e2e/runner/setup.go
+++ b/test/e2e/runner/setup.go
@@ -284,7 +284,11 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) {
 		cfg.Mempool.Version = node.Mempool
 	}
 
-	cfg.FastSyncMode = node.FastSync
+	if node.BlockSync == "" {
+		cfg.FastSyncMode = false
+	} else {
+		cfg.BlockSync.Version = node.BlockSync
+	}
 
 	if node.StateSync {
 		cfg.StateSync.Enable = true