From 73aae62f30acdc56816ad65550438d8830ac83db Mon Sep 17 00:00:00 2001
From: Michael Tsitrin <114929630+mtsitrin@users.noreply.github.com>
Date: Wed, 15 May 2024 21:03:11 +0300
Subject: [PATCH] feat(blockManager): refactor and use state as single source
 of truth for height (#847)

Co-authored-by: danwt <30197399+danwt@users.noreply.github.com>
---
 .gitignore                                    |   3 +-
 block/block.go                                | 141 +++++-------------
 block/executor.go                             |  20 +--
 block/executor_test.go                        |  32 ++--
 block/gossip.go                               |  54 +++++++
 block/initchain.go                            |   7 +-
 block/manager.go                              |  68 +--------
 block/manager_test.go                         | 127 +++++++---------
 block/produce.go                              |  51 +++----
 block/production_test.go                      |  32 ++--
 block/pruning.go                              |  13 +-
 block/retriever.go                            |   8 +-
 block/state.go                                | 106 +++++++------
 block/submit.go                               |   5 +-
 block/submit_test.go                          |  18 +--
 block/synctarget.go                           |   4 +-
 block/types.go                                |  11 ++
 .../blockindexer}/block.go                    |   0
 .../block => indexers/blockindexer}/kv/kv.go  |  11 +-
 .../blockindexer}/kv/kv_test.go               |   2 +-
 .../blockindexer}/kv/util.go                  |   0
 .../blockindexer}/null/null.go                |   2 +-
 .../blockindexer}/query_range.go              |   0
 {state => indexers}/txindex/indexer.go        |   2 -
 .../txindex/indexer_service.go                |   4 +-
 .../txindex/indexer_service_test.go           |   6 +-
 {state => indexers}/txindex/kv/kv.go          |  13 +-
 .../txindex/kv/kv_bench_test.go               |   0
 {state => indexers}/txindex/kv/kv_test.go     |   2 +-
 {state => indexers}/txindex/kv/utils.go       |   0
 {state => indexers}/txindex/kv/utils_test.go  |   0
 {state => indexers}/txindex/null/null.go      |   2 +-
 mempool/cache.go                              |   2 +-
 mempool/v1/mempool.go                         |   2 +-
 node/node.go                                  |  18 ++-
 p2p/validator_test.go                         |   2 +-
 rpc/client/client.go                          |  27 ++--
 rpc/client/client_test.go                     | 130 ++++++++--------
 store/kv.go                                   |  29 ----
 store/pruning.go                              |  31 ++--
 store/pruning_test.go                         |  73 +++++----
 store/store.go                                |  57 +------
 store/{types.go => storeIface.go}             |  55 ++++---
 store/store_test.go                           |  61 ++------
 test/loadtime/cmd/report/main.go              |  13 +-
 testutil/block.go                             |   6 +-
 testutil/mocks.go                             |  22 +--
 testutil/types.go                             |  20 +--
 types/serialization.go                        |  34 +----
 types/serialization_test.go                   |  22 +--
 types/state.go                                |  88 +++++------
 types/validation.go                           |  13 +-
 52 files changed, 632 insertions(+), 817 deletions(-)
 create mode 100644 block/gossip.go
 rename {state/indexer => indexers/blockindexer}/block.go (100%)
 rename {state/indexer/block => indexers/blockindexer}/kv/kv.go (97%)
 rename {state/indexer/block => indexers/blockindexer}/kv/kv_test.go (97%)
 rename {state/indexer/block => indexers/blockindexer}/kv/util.go (100%)
 rename {state/indexer/block => indexers/blockindexer}/null/null.go (90%)
 rename {state/indexer => indexers/blockindexer}/query_range.go (100%)
 rename {state => indexers}/txindex/indexer.go (95%)
 rename {state => indexers}/txindex/indexer_service.go (95%)
 rename {state => indexers}/txindex/indexer_service_test.go (91%)
 rename {state => indexers}/txindex/kv/kv.go (97%)
 rename {state => indexers}/txindex/kv/kv_bench_test.go (100%)
 rename {state => indexers}/txindex/kv/kv_test.go (99%)
 rename {state => indexers}/txindex/kv/utils.go (100%)
 rename {state => indexers}/txindex/kv/utils_test.go (100%)
 rename {state => indexers}/txindex/null/null.go (94%)
 rename store/{types.go => storeIface.go} (60%)

diff --git a/.gitignore b/.gitignore
index c046ac465..3004a5b74 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@ proto/pb
 .go-version
 build
 
-vendor/
\ No newline at end of file
+vendor/
+da/grpc/mockserv/db/
diff --git a/block/block.go b/block/block.go
index 02c7ce3c2..78d8255f9 100644
--- a/block/block.go
+++ b/block/block.go
@@ -1,27 +1,23 @@
 package block
 
 import (
-	"context"
 	"fmt"
 
 	errorsmod "cosmossdk.io/errors"
 
-	"github.com/dymensionxyz/dymint/p2p"
 	"github.com/dymensionxyz/dymint/types"
-	tmtypes "github.com/tendermint/tendermint/types"
 )
 
 // applyBlock applies the block to the store and the abci app.
 // Contract: block and commit must be validated before calling this function!
-// steps: save block -> execute block with app -> update state -> commit block to app -> update store height and state hash.
+// steps: save block -> execute block with app -> update state -> commit block to app -> update state's height and commit result.
 // As the entire process can't be atomic we need to make sure the following condition apply before
 // - block height is the expected block height on the store (height + 1).
 // - block height is the expected block height on the app (last block height + 1).
 func (m *Manager) applyBlock(block *types.Block, commit *types.Commit, blockMetaData blockMetaData) error {
-	// TODO (#330): allow genesis block with height > 0 to be applied.
 	// TODO: add switch case to have defined behavior for each case.
 	// validate block height
-	if block.Header.Height != m.Store.NextHeight() {
+	if block.Header.Height != m.State.NextHeight() {
 		return types.ErrInvalidBlockHeight
 	}
 
@@ -35,6 +31,8 @@ func (m *Manager) applyBlock(block *types.Block, commit *types.Commit, blockMeta
 	// In case the following true, it means we crashed after the commit and before updating the store height.
 	// In that case we'll want to align the store with the app state and continue to the next block.
 	if isBlockAlreadyApplied {
+		// In this case, where the app was committed, but the state wasn't updated
+		// it will update the state from appInfo, saved responses and validators.
 		err := m.UpdateStateFromApp()
 		if err != nil {
 			return fmt.Errorf("update state from app: %w", err)
@@ -48,83 +46,82 @@ func (m *Manager) applyBlock(block *types.Block, commit *types.Commit, blockMeta
 		return fmt.Errorf("save block: %w", err)
 	}
 
-	responses, err := m.Executor.ExecuteBlock(m.LastState, block)
+	responses, err := m.Executor.ExecuteBlock(m.State, block)
 	if err != nil {
 		return fmt.Errorf("execute block: %w", err)
 	}
 
-	newState, err := m.Executor.UpdateStateFromResponses(responses, m.LastState, block)
+	dbBatch := m.Store.NewBatch()
+	dbBatch, err = m.Store.SaveBlockResponses(block.Header.Height, responses, dbBatch)
 	if err != nil {
-		return fmt.Errorf("update state from responses: %w", err)
-	}
-
-	batch := m.Store.NewBatch()
-
-	batch, err = m.Store.SaveBlockResponses(block.Header.Height, responses, batch)
-	if err != nil {
-		batch.Discard()
+		dbBatch.Discard()
 		return fmt.Errorf("save block responses: %w", err)
 	}
 
-	m.LastState = newState
-	batch, err = m.Store.UpdateState(m.LastState, batch)
+	// Get the validator changes from the app
+	validators, err := m.Executor.NextValSetFromResponses(m.State, responses, block)
 	if err != nil {
-		batch.Discard()
-		return fmt.Errorf("update state: %w", err)
+		return fmt.Errorf("update state from responses: %w", err)
 	}
-	batch, err = m.Store.SaveValidators(block.Header.Height, m.LastState.Validators, batch)
+
+	dbBatch, err = m.Store.SaveValidators(block.Header.Height, validators, dbBatch)
 	if err != nil {
-		batch.Discard()
+		dbBatch.Discard()
 		return fmt.Errorf("save validators: %w", err)
 	}
 
-	err = batch.Commit()
+	err = dbBatch.Commit()
 	if err != nil {
 		return fmt.Errorf("commit batch to disk: %w", err)
 	}
 
 	// Commit block to app
-	retainHeight, err := m.Executor.Commit(&newState, block, responses)
+	appHash, retainHeight, err := m.Executor.Commit(m.State, block, responses)
 	if err != nil {
 		return fmt.Errorf("commit block: %w", err)
 	}
 
+	// If failed here, after the app committed, but before the state is updated, we'll update the state on
+	// UpdateStateFromApp using the saved responses and validators.
+
+	// Update the state with the new app hash, last validators and store height from the commit.
+	// Every one of those, if happens before commit, prevents us from re-executing the block in case failed during commit.
+	m.Executor.UpdateStateAfterCommit(m.State, responses, appHash, block.Header.Height, validators)
+	_, err = m.Store.SaveState(m.State, nil)
+	if err != nil {
+		return fmt.Errorf("update state: %w", err)
+	}
+
 	// Prune old heights, if requested by ABCI app.
 	if retainHeight > 0 {
-		pruned, err := m.pruneBlocks(retainHeight)
+		_, err := m.pruneBlocks(uint64(retainHeight))
 		if err != nil {
 			m.logger.Error("prune blocks", "retain_height", retainHeight, "err", err)
-		} else {
-			m.logger.Debug("pruned blocks", "pruned", pruned, "retain_height", retainHeight)
 		}
 	}
+	return nil
+}
 
-	// Update the state with the new app hash, last validators and store height from the commit.
-	// Every one of those, if happens before commit, prevents us from re-executing the block in case failed during commit.
-	newState.LastValidators = m.LastState.Validators.Copy()
-	newState.LastStoreHeight = block.Header.Height
-	newState.BaseHeight = m.Store.Base()
-
-	_, err = m.Store.UpdateState(newState, nil)
+// isHeightAlreadyApplied checks if the block height is already applied to the app.
+func (m *Manager) isHeightAlreadyApplied(blockHeight uint64) (bool, error) {
+	proxyAppInfo, err := m.Executor.GetAppInfo()
 	if err != nil {
-		return fmt.Errorf("final update state: %w", err)
+		return false, errorsmod.Wrap(err, "get app info")
 	}
-	m.LastState = newState
 
-	if ok := m.Store.SetHeight(block.Header.Height); !ok {
-		return fmt.Errorf("store set height: %d", block.Header.Height)
-	}
+	isBlockAlreadyApplied := uint64(proxyAppInfo.LastBlockHeight) == blockHeight
 
-	return nil
+	// TODO: add switch case to validate better the current app state
+
+	return isBlockAlreadyApplied, nil
 }
 
-// TODO: move to gossip.go
 func (m *Manager) attemptApplyCachedBlocks() error {
 	m.retrieverMutex.Lock()
 	defer m.retrieverMutex.Unlock()
 
 	for {
-		expectedHeight := m.Store.NextHeight()
+		expectedHeight := m.State.NextHeight()
 
 		cachedBlock, blockExists := m.blockCache[expectedHeight]
 		if !blockExists {
@@ -148,68 +145,10 @@ func (m *Manager) attemptApplyCachedBlocks() error {
 	return nil
 }
 
-// isHeightAlreadyApplied checks if the block height is already applied to the app.
-func (m *Manager) isHeightAlreadyApplied(blockHeight uint64) (bool, error) {
-	proxyAppInfo, err := m.Executor.GetAppInfo()
-	if err != nil {
-		return false, errorsmod.Wrap(err, "get app info")
-	}
-
-	isBlockAlreadyApplied := uint64(proxyAppInfo.LastBlockHeight) == blockHeight
-
-	// TODO: add switch case to validate better the current app state
-
-	return isBlockAlreadyApplied, nil
-}
-
-// UpdateStateFromApp is responsible for aligning the state of the store from the abci app
-func (m *Manager) UpdateStateFromApp() error {
-	proxyAppInfo, err := m.Executor.GetAppInfo()
-	if err != nil {
-		return errorsmod.Wrap(err, "get app info")
-	}
-
-	appHeight := uint64(proxyAppInfo.LastBlockHeight)
-
-	// update the state with the hash, last store height and last validators.
-	m.LastState.AppHash = *(*[32]byte)(proxyAppInfo.LastBlockAppHash)
-	m.LastState.LastStoreHeight = appHeight
-	m.LastState.LastValidators = m.LastState.Validators.Copy()
-
-	resp, err := m.Store.LoadBlockResponses(appHeight)
-	if err != nil {
-		return errorsmod.Wrap(err, "load block responses")
-	}
-	copy(m.LastState.LastResultsHash[:], tmtypes.NewResults(resp.DeliverTxs).Hash())
-
-	_, err = m.Store.UpdateState(m.LastState, nil)
-	if err != nil {
-		return errorsmod.Wrap(err, "update state")
-	}
-	if ok := m.Store.SetHeight(appHeight); !ok {
-		return fmt.Errorf("store set height: %d", appHeight)
-	}
-	return nil
-}
-
 func (m *Manager) validateBlock(block *types.Block, commit *types.Commit) error {
 	// Currently we're assuming proposer is never nil as it's a pre-condition for
 	// dymint to start
 	proposer := m.SLClient.GetProposer()
 
-	return types.ValidateProposedTransition(m.LastState, block, commit, proposer)
-}
-
-func (m *Manager) gossipBlock(ctx context.Context, block types.Block, commit types.Commit) error {
-	gossipedBlock := p2p.GossipedBlock{Block: block, Commit: commit}
-	gossipedBlockBytes, err := gossipedBlock.MarshalBinary()
-	if err != nil {
-		return fmt.Errorf("marshal binary: %w: %w", err, ErrNonRecoverable)
-	}
-	if err := m.p2pClient.GossipBlock(ctx, gossipedBlockBytes); err != nil {
-		// Although this boils down to publishing on a topic, we don't want to speculate too much on what
-		// could cause that to fail, so we assume recoverable.
-		return fmt.Errorf("p2p gossip block: %w: %w", err, ErrRecoverable)
-	}
-	return nil
+	return types.ValidateProposedTransition(m.State, block, commit, proposer)
 }
diff --git a/block/executor.go b/block/executor.go
index e44e2deb3..6d0fc1e7e 100644
--- a/block/executor.go
+++ b/block/executor.go
@@ -96,7 +96,7 @@ func (e *Executor) InitChain(genesis *tmtypes.GenesisDoc, validators []*tmtypes.
 }
 
 // CreateBlock reaps transactions from mempool and builds a block.
-func (e *Executor) CreateBlock(height uint64, lastCommit *types.Commit, lastHeaderHash [32]byte, state types.State, maxBytes uint64) *types.Block {
+func (e *Executor) CreateBlock(height uint64, lastCommit *types.Commit, lastHeaderHash [32]byte, state *types.State, maxBytes uint64) *types.Block {
 	if state.ConsensusParams.Block.MaxBytes > 0 {
 		maxBytes = min(maxBytes, uint64(state.ConsensusParams.Block.MaxBytes))
 	}
@@ -134,21 +134,18 @@ func (e *Executor) CreateBlock(height uint64, lastCommit *types.Commit, lastHead
 }
 
 // Commit commits the block
-func (e *Executor) Commit(state *types.State, block *types.Block, resp *tmstate.ABCIResponses) (int64, error) {
+func (e *Executor) Commit(state *types.State, block *types.Block, resp *tmstate.ABCIResponses) ([]byte, int64, error) {
 	appHash, retainHeight, err := e.commit(state, block, resp.DeliverTxs)
 	if err != nil {
-		return 0, err
+		return nil, 0, err
 	}
 
-	copy(state.AppHash[:], appHash[:])
-	copy(state.LastResultsHash[:], tmtypes.NewResults(resp.DeliverTxs).Hash())
-
-	err = e.publishEvents(resp, block, *state)
+	err = e.publishEvents(resp, block)
 	if err != nil {
 		e.logger.Error("fire block events", "error", err)
-		return 0, err
+		return nil, 0, err
 	}
-	return retainHeight, nil
+	return appHash, retainHeight, nil
 }
 
 // GetAppInfo returns the latest AppInfo from the proxyApp.
@@ -183,7 +180,7 @@ func (e *Executor) commit(state *types.State, block *types.Block, deliverTxs []*
 }
 
 // ExecuteBlock executes the block and returns the ABCIResponses. Block should be valid (passed validation checks).
-func (e *Executor) ExecuteBlock(state types.State, block *types.Block) (*tmstate.ABCIResponses, error) {
+func (e *Executor) ExecuteBlock(state *types.State, block *types.Block) (*tmstate.ABCIResponses, error) {
 	abciResponses := new(tmstate.ABCIResponses)
 	abciResponses.DeliverTxs = make([]*abci.ResponseDeliverTx, len(block.Data.Txs))
 
@@ -252,13 +249,12 @@ func (e *Executor) getDataHash(block *types.Block) []byte {
 	return abciData.Hash()
 }
 
-func (e *Executor) publishEvents(resp *tmstate.ABCIResponses, block *types.Block, state types.State) error {
+func (e *Executor) publishEvents(resp *tmstate.ABCIResponses, block *types.Block) error {
 	if e.eventBus == nil {
 		return nil
 	}
 
 	abciBlock, err := types.ToABCIBlock(block)
-	abciBlock.Header.ValidatorsHash = state.Validators.Hash()
 	if err != nil {
 		return err
 	}
diff --git a/block/executor_test.go b/block/executor_test.go
index d09a18be3..e4eca2f55 100644
--- a/block/executor_test.go
+++ b/block/executor_test.go
@@ -51,7 +51,7 @@ func TestCreateBlock(t *testing.T) {
 
 	maxBytes := uint64(100)
 
-	state := types.State{}
+	state := &types.State{}
 	state.ConsensusParams.Block.MaxBytes = int64(maxBytes)
 	state.ConsensusParams.Block.MaxGas = 100000
 	state.Validators = tmtypes.NewValidatorSet(nil)
@@ -140,13 +140,12 @@ func TestApplyBlock(t *testing.T) {
 	require.NotNil(headerSub)
 
 	// Init state
-	state := types.State{
+	state := &types.State{
 		NextValidators: tmtypes.NewValidatorSet(nil),
 		Validators:     tmtypes.NewValidatorSet(nil),
-		LastValidators: tmtypes.NewValidatorSet(nil),
 	}
 	state.InitialHeight = 1
-	state.LastBlockHeight = 0
+	state.LastBlockHeight.Store(0)
 	maxBytes := uint64(100)
 	state.ConsensusParams.Block.MaxBytes = int64(maxBytes)
 	state.ConsensusParams.Block.MaxGas = 100000
@@ -182,21 +181,18 @@ func TestApplyBlock(t *testing.T) {
 	resp, err := executor.ExecuteBlock(state, block)
 	require.NoError(err)
 	require.NotNil(resp)
-	newState, err := executor.UpdateStateFromResponses(resp, state, block)
+	appHash, _, err := executor.Commit(state, block, resp)
 	require.NoError(err)
-	require.NotNil(newState)
-	assert.Equal(int64(1), newState.LastBlockHeight)
-	_, err = executor.Commit(&newState, block, resp)
-	require.NoError(err)
-	assert.Equal(mockAppHash, newState.AppHash)
-	newState.LastStoreHeight = uint64(newState.LastBlockHeight)
+	executor.UpdateStateAfterCommit(state, resp, appHash, block.Header.Height, state.Validators)
+	assert.Equal(uint64(1), state.Height())
+	assert.Equal(mockAppHash, state.AppHash)
 
 	// Create another block with multiple Tx from mempool
 	require.NoError(mpool.CheckTx([]byte{0, 1, 2, 3, 4}, func(r *abci.Response) {}, mempool.TxInfo{}))
 	require.NoError(mpool.CheckTx([]byte{5, 6, 7, 8, 9}, func(r *abci.Response) {}, mempool.TxInfo{}))
 	require.NoError(mpool.CheckTx([]byte{1, 2, 3, 4, 5}, func(r *abci.Response) {}, mempool.TxInfo{}))
 	require.NoError(mpool.CheckTx(make([]byte, 90), func(r *abci.Response) {}, mempool.TxInfo{}))
-	block = executor.CreateBlock(2, commit, [32]byte{}, newState, maxBytes)
+	block = executor.CreateBlock(2, commit, [32]byte{}, state, maxBytes)
 	require.NotNil(block)
 	assert.Equal(uint64(2), block.Header.Height)
 	assert.Len(block.Data.Txs, 3)
@@ -217,7 +213,7 @@ func TestApplyBlock(t *testing.T) {
 	}
 
 	// Apply the block with an invalid commit
-	err = types.ValidateProposedTransition(newState, block, invalidCommit, proposer)
+	err = types.ValidateProposedTransition(state, block, invalidCommit, proposer)
 
 	require.ErrorIs(err, types.ErrInvalidSignature)
 
@@ -231,17 +227,17 @@ func TestApplyBlock(t *testing.T) {
 	}
 
 	// Apply the block
-	err = types.ValidateProposedTransition(newState, block, commit, proposer)
+	err = types.ValidateProposedTransition(state, block, commit, proposer)
 	require.NoError(err)
 	resp, err = executor.ExecuteBlock(state, block)
 	require.NoError(err)
 	require.NotNil(resp)
-	newState, err = executor.UpdateStateFromResponses(resp, state, block)
+	vals, err := executor.NextValSetFromResponses(state, resp, block)
 	require.NoError(err)
-	require.NotNil(newState)
-	assert.Equal(int64(2), newState.LastBlockHeight)
-	_, err = executor.Commit(&newState, block, resp)
+	_, _, err = executor.Commit(state, block, resp)
 	require.NoError(err)
+	executor.UpdateStateAfterCommit(state, resp, appHash, block.Header.Height, vals)
+	assert.Equal(uint64(2), state.Height())
 
 	// wait for at least 4 Tx events, for up to 3 second.
 	// 3 seconds is a fail-scenario only
diff --git a/block/gossip.go b/block/gossip.go
new file mode 100644
index 000000000..9ba4fb2d4
--- /dev/null
+++ b/block/gossip.go
@@ -0,0 +1,54 @@
+package block
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/dymensionxyz/dymint/p2p"
+	"github.com/dymensionxyz/dymint/types"
+	"github.com/tendermint/tendermint/libs/pubsub"
+)
+
+// onNewGossippedBlock will take a block and apply it
+func (m *Manager) onNewGossipedBlock(event pubsub.Message) {
+	eventData, _ := event.Data().(p2p.GossipedBlock)
+	block := eventData.Block
+	commit := eventData.Commit
+	m.retrieverMutex.Lock() // needed to protect blockCache access
+	_, found := m.blockCache[block.Header.Height]
+	// It is not strictly necessary to return early, for correctness, but doing so helps us avoid mutex pressure and unnecessary repeated attempts to apply cached blocks
+	if found {
+		m.retrieverMutex.Unlock()
+		return
+	}
+
+	m.logger.Debug("Received new block via gossip", "block height", block.Header.Height, "store height", m.State.Height(), "n cachedBlocks", len(m.blockCache))
+
+	nextHeight := m.State.NextHeight()
+	if block.Header.Height >= nextHeight {
+		m.blockCache[block.Header.Height] = CachedBlock{
+			Block:  &block,
+			Commit: &commit,
+		}
+	}
+	m.retrieverMutex.Unlock() // have to give this up as it's locked again in attempt apply, and we're not re-entrant
+
+	err := m.attemptApplyCachedBlocks()
+	if err != nil {
+		m.logger.Error("applying cached blocks", "err", err)
+	}
+}
+
+func (m *Manager) gossipBlock(ctx context.Context, block types.Block, commit types.Commit) error {
+	gossipedBlock := p2p.GossipedBlock{Block: block, Commit: commit}
+	gossipedBlockBytes, err := gossipedBlock.MarshalBinary()
+	if err != nil {
+		return fmt.Errorf("marshal binary: %w: %w", err, ErrNonRecoverable)
+	}
+	if err := m.p2pClient.GossipBlock(ctx, gossipedBlockBytes); err != nil {
+		// Although this boils down to publishing on a topic, we don't want to speculate too much on what
+		// could cause that to fail, so we assume recoverable.
+		return fmt.Errorf("p2p gossip block: %w: %w", err, ErrRecoverable)
+	}
+	return nil
+}
diff --git a/block/initchain.go b/block/initchain.go
index 467246155..c7c694c1f 100644
--- a/block/initchain.go
+++ b/block/initchain.go
@@ -23,10 +23,9 @@ func (m *Manager) RunInitChain(ctx context.Context) error {
 	}
 
 	// update the state with only the consensus pubkey
-	m.Executor.UpdateStateAfterInitChain(&m.LastState, res, gensisValSet)
-	m.Executor.UpdateMempoolAfterInitChain(&m.LastState)
-
-	if _, err := m.Store.UpdateState(m.LastState, nil); err != nil {
+	m.Executor.UpdateStateAfterInitChain(m.State, res, gensisValSet)
+	m.Executor.UpdateMempoolAfterInitChain(m.State)
+	if _, err := m.Store.SaveState(m.State, nil); err != nil {
 		return err
 	}
 
diff --git a/block/manager.go b/block/manager.go
index e328a9de1..41e1f014f 100644
--- a/block/manager.go
+++ b/block/manager.go
@@ -9,6 +9,7 @@ import (
 	"sync/atomic"
 
 	"github.com/dymensionxyz/dymint/gerr"
+	"github.com/dymensionxyz/dymint/store"
 
 	uevent "github.com/dymensionxyz/dymint/utils/event"
 
@@ -16,8 +17,6 @@ import (
 
 	"github.com/dymensionxyz/dymint/p2p"
 	"github.com/libp2p/go-libp2p/core/crypto"
-
-	tmcrypto "github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/libs/pubsub"
 	tmtypes "github.com/tendermint/tendermint/types"
 
@@ -27,7 +26,6 @@ import (
 	"github.com/dymensionxyz/dymint/da"
 	"github.com/dymensionxyz/dymint/mempool"
 	"github.com/dymensionxyz/dymint/settlement"
-	"github.com/dymensionxyz/dymint/store"
 	"github.com/dymensionxyz/dymint/types"
 )
 
@@ -39,9 +37,9 @@ type Manager struct {
 	ProposerKey crypto.PrivKey
 
 	// Store and execution
-	Store     store.Store
-	LastState types.State
-	Executor  *Executor
+	Store    store.Store
+	State    *types.State
+	Executor *Executor
 
 	// Clients and servers
 	Pubsub    *pubsub.Server
@@ -108,7 +106,7 @@ func NewManager(
 		ProposerKey:     proposerKey,
 		Conf:            conf,
 		Genesis:         genesis,
-		LastState:       s,
+		State:           s,
 		Store:           store,
 		Executor:        exec,
 		DAClient:        dalc,
@@ -137,7 +135,7 @@ func (m *Manager) Start(ctx context.Context) error {
 	m.logger.Info("Starting block manager", "isSequencer", isSequencer)
 
 	// Check if InitChain flow is needed
-	if m.LastState.IsGenesis() {
+	if m.State.IsGenesis() {
 		m.logger.Info("Running InitChain")
 
 		err := m.RunInitChain(ctx)
@@ -172,7 +170,7 @@ func (m *Manager) syncBlockManager() error {
 	res, err := m.SLClient.RetrieveBatch()
 	if errors.Is(err, gerr.ErrNotFound) {
 		// The SL hasn't got any batches for this chain yet.
-		m.logger.Info("No batches for chain found in SL. Start writing first batch.")
+		m.logger.Info("No batches for chain found in SL.")
 		m.SyncTarget.Store(uint64(m.Genesis.InitialHeight - 1))
 		return nil
 	}
@@ -187,7 +185,7 @@ func (m *Manager) syncBlockManager() error {
 		return err
 	}
 
-	m.logger.Info("Synced.", "current height", m.Store.Height(), "syncTarget", m.SyncTarget.Load())
+	m.logger.Info("Synced.", "current height", m.State.Height(), "syncTarget", m.SyncTarget.Load())
 	return nil
 }
 
@@ -197,53 +195,3 @@ func (m *Manager) UpdateSyncParams(endHeight uint64) {
 	m.logger.Info("Received new syncTarget", "syncTarget", endHeight)
 	m.SyncTarget.Store(endHeight)
 }
-
-func getAddress(key crypto.PrivKey) ([]byte, error) {
-	rawKey, err := key.GetPublic().Raw()
-	if err != nil {
-		return nil, err
-	}
-	return tmcrypto.AddressHash(rawKey), nil
-}
-
-// TODO: move to gossip.go
-// onNewGossippedBlock will take a block and apply it
-func (m *Manager) onNewGossipedBlock(event pubsub.Message) {
-	eventData, _ := event.Data().(p2p.GossipedBlock)
-	block := eventData.Block
-	commit := eventData.Commit
-	m.retrieverMutex.Lock() // needed to protect blockCache access
-	_, found := m.blockCache[block.Header.Height]
-	// It is not strictly necessary to return early, for correctness, but doing so helps us avoid mutex pressure and unnecessary repeated attempts to apply cached blocks
-	if found {
-		m.retrieverMutex.Unlock()
-		return
-	}
-
-	m.logger.Debug("Received new block via gossip", "block height", block.Header.Height, "store height", m.Store.Height(), "n cachedBlocks", len(m.blockCache))
-
-	nextHeight := m.Store.NextHeight()
-	if block.Header.Height >= nextHeight {
-		m.blockCache[block.Header.Height] = CachedBlock{
-			Block:  &block,
-			Commit: &commit,
-		}
-	}
-	m.retrieverMutex.Unlock() // have to give this up as it's locked again in attempt apply, and we're not re-entrant
-
-	err := m.attemptApplyCachedBlocks()
-	if err != nil {
-		m.logger.Error("applying cached blocks", "err", err)
-	}
-}
-
-// getInitialState tries to load lastState from Store, and if it's not available it reads GenesisDoc.
-func getInitialState(store store.Store, genesis *tmtypes.GenesisDoc, logger types.Logger) (types.State, error) {
-	s, err := store.LoadState()
-	if errors.Is(err, types.ErrNoStateFound) {
-		logger.Info("failed to find state in the store, creating new state from genesis")
-		return types.NewFromGenesisDoc(genesis)
-	}
-
-	return s, err
-}
diff --git a/block/manager_test.go b/block/manager_test.go
index ca23601b8..4c08adee6 100644
--- a/block/manager_test.go
+++ b/block/manager_test.go
@@ -47,7 +47,7 @@ func TestInitialState(t *testing.T) {
 	// Init empty store and full store
 	emptyStore := store.New(store.NewDefaultInMemoryKVStore())
 	fullStore := store.New(store.NewDefaultInMemoryKVStore())
-	_, err = fullStore.UpdateState(sampleState, nil)
+	_, err = fullStore.SaveState(sampleState, nil)
 	require.NoError(t, err)
 
 	// Init p2p client
@@ -69,15 +69,15 @@ func TestInitialState(t *testing.T) {
 		name                    string
 		store                   store.Store
 		genesis                 *tmtypes.GenesisDoc
-		expectedInitialHeight   int64
-		expectedLastBlockHeight int64
+		expectedInitialHeight   uint64
+		expectedLastBlockHeight uint64
 		expectedChainID         string
 	}{
 		{
 			name:                    "empty store",
 			store:                   emptyStore,
 			genesis:                 genesis,
-			expectedInitialHeight:   genesis.InitialHeight,
+			expectedInitialHeight:   uint64(genesis.InitialHeight),
 			expectedLastBlockHeight: 0,
 			expectedChainID:         genesis.ChainID,
 		},
@@ -86,7 +86,7 @@ func TestInitialState(t *testing.T) {
 			store:                   fullStore,
 			genesis:                 genesis,
 			expectedInitialHeight:   sampleState.InitialHeight,
-			expectedLastBlockHeight: sampleState.LastBlockHeight,
+			expectedLastBlockHeight: sampleState.LastBlockHeight.Load(),
 			expectedChainID:         sampleState.ChainID,
 		},
 	}
@@ -98,9 +98,9 @@ func TestInitialState(t *testing.T) {
 				nil, pubsubServer, p2pClient, logger)
 			assert.NoError(err)
 			assert.NotNil(agg)
-			assert.Equal(c.expectedChainID, agg.LastState.ChainID)
-			assert.Equal(c.expectedInitialHeight, agg.LastState.InitialHeight)
-			assert.Equal(c.expectedLastBlockHeight, agg.LastState.LastBlockHeight)
+			assert.Equal(c.expectedChainID, agg.State.ChainID)
+			assert.Equal(c.expectedInitialHeight, agg.State.InitialHeight)
+			assert.Equal(c.expectedLastBlockHeight, agg.State.LastBlockHeight.Load())
 		})
 	}
 }
@@ -135,7 +135,7 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 
 	// Initially sync target is 0
 	assert.Zero(t, manager.SyncTarget.Load())
-	assert.True(t, manager.Store.Height() == 0)
+	assert.True(t, manager.State.Height() == 0)
 
 	// enough time to sync and produce blocks
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*4)
@@ -150,7 +150,7 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 	<-ctx.Done()
 	assert.Equal(t, batch.EndHeight, manager.SyncTarget.Load())
 	// validate that we produced blocks
-	assert.Greater(t, manager.Store.Height(), batch.EndHeight)
+	assert.Greater(t, manager.State.Height(), batch.EndHeight)
 }
 
 func TestRetrieveDaBatchesFailed(t *testing.T) {
@@ -184,8 +184,8 @@ func TestProduceNewBlock(t *testing.T) {
 	_, _, err = manager.ProduceAndGossipBlock(context.Background(), true)
 	require.NoError(t, err)
 	// Validate state is updated with the commit hash
-	assert.Equal(t, uint64(1), manager.Store.Height())
-	assert.Equal(t, commitHash, manager.LastState.AppHash)
+	assert.Equal(t, uint64(1), manager.State.Height())
+	assert.Equal(t, commitHash, manager.State.AppHash)
 }
 
 func TestProducePendingBlock(t *testing.T) {
@@ -202,16 +202,17 @@ func TestProducePendingBlock(t *testing.T) {
 	manager, err := testutil.GetManager(testutil.GetManagerConfig(), nil, nil, 1, 1, 0, proxyApp, nil)
 	require.NoError(t, err)
 	// Generate block and commit and save it to the store
-	blocks, err := testutil.GenerateBlocks(1, 1, manager.ProposerKey)
-	require.NoError(t, err)
-	block := blocks[0]
+	block := testutil.GetRandomBlock(1, 3)
 	_, err = manager.Store.SaveBlock(block, &block.LastCommit, nil)
 	require.NoError(t, err)
 	// Produce block
 	_, _, err = manager.ProduceAndGossipBlock(context.Background(), true)
 	require.NoError(t, err)
 	// Validate state is updated with the block that was saved in the store
-	assert.Equal(t, block.Header.Hash(), *(*[32]byte)(manager.LastState.LastBlockID.Hash))
+
+	// TODO: fix this test
+	// hacky way to validate the block was indeed contain txs
+	assert.NotEqual(t, manager.State.LastResultsHash, testutil.GetEmptyLastResultsHash())
 }
 
 // Test that in case we fail after the proxy app commit, next time we won't commit again to the proxy app
@@ -223,6 +224,7 @@ func TestProducePendingBlock(t *testing.T) {
 // 5. Produce third block successfully
 func TestProduceBlockFailAfterCommit(t *testing.T) {
 	require := require.New(t)
+	assert := assert.New(t)
 	// Setup app
 	app := testutil.GetAppMock(testutil.Info, testutil.Commit)
 	// Create proxy app
@@ -237,64 +239,50 @@ func TestProduceBlockFailAfterCommit(t *testing.T) {
 	require.NoError(err)
 
 	cases := []struct {
-		name                   string
-		shouldFailSetSetHeight bool
-		shouldFailUpdateState  bool
-		LastAppBlockHeight     int64
-		AppCommitHash          [32]byte
-		LastAppCommitHash      [32]byte
-		expectedStoreHeight    uint64
-		expectedStateAppHash   [32]byte
+		name                 string
+		shoudFailOnSaveState bool
+		LastAppBlockHeight   int64
+		AppCommitHash        [32]byte
+		LastAppCommitHash    [32]byte
+		expectedStoreHeight  uint64
+		expectedStateAppHash [32]byte
 	}{
 		{
-			name:                   "ProduceFirstBlockSuccessfully",
-			shouldFailSetSetHeight: false,
-			shouldFailUpdateState:  false,
-			AppCommitHash:          [32]byte{1},
-			LastAppCommitHash:      [32]byte{0},
-			LastAppBlockHeight:     0,
-			expectedStoreHeight:    1,
-			expectedStateAppHash:   [32]byte{1},
+			name:                 "ProduceFirstBlockSuccessfully",
+			shoudFailOnSaveState: false,
+			AppCommitHash:        [32]byte{1},
+			expectedStoreHeight:  1,
+			expectedStateAppHash: [32]byte{1},
 		},
 		{
-			name:                   "ProduceSecondBlockFailOnUpdateState",
-			shouldFailSetSetHeight: false,
-			shouldFailUpdateState:  true,
-			AppCommitHash:          [32]byte{2},
-			LastAppCommitHash:      [32]byte{},
-			LastAppBlockHeight:     0,
-			expectedStoreHeight:    1,
-			expectedStateAppHash:   [32]byte{1},
+			name:                 "ProduceSecondBlockFailOnUpdateState",
+			shoudFailOnSaveState: true,
+			AppCommitHash:        [32]byte{2},
+			expectedStoreHeight:  1, // height not changed on failed save state
+			expectedStateAppHash: [32]byte{1},
 		},
 		{
-			name:                   "ProduceSecondBlockSuccessfully",
-			shouldFailSetSetHeight: false,
-			shouldFailUpdateState:  false,
-			AppCommitHash:          [32]byte{},
-			LastAppCommitHash:      [32]byte{2},
-			LastAppBlockHeight:     2,
-			expectedStoreHeight:    2,
-			expectedStateAppHash:   [32]byte{2},
+			name:                 "ProduceSecondBlockSuccessfullyFromApp",
+			shoudFailOnSaveState: false,
+			LastAppCommitHash:    [32]byte{2}, // loading state from app
+			LastAppBlockHeight:   2,
+			expectedStoreHeight:  2,
+			expectedStateAppHash: [32]byte{2},
 		},
 		{
-			name:                   "ProduceThirdBlockFailOnUpdateStoreHeight",
-			shouldFailSetSetHeight: true,
-			shouldFailUpdateState:  false,
-			AppCommitHash:          [32]byte{3},
-			LastAppCommitHash:      [32]byte{2},
-			LastAppBlockHeight:     2,
-			expectedStoreHeight:    2,
-			expectedStateAppHash:   [32]byte{3},
+			name:                 "ProduceThirdBlockFailOnUpdateStoreHeight",
+			shoudFailOnSaveState: true,
+			AppCommitHash:        [32]byte{3},
+			expectedStoreHeight:  2, // height not changed on failed save state
+			expectedStateAppHash: [32]byte{2},
 		},
 		{
-			name:                   "ProduceThirdBlockSuccessfully",
-			shouldFailSetSetHeight: false,
-			shouldFailUpdateState:  false,
-			AppCommitHash:          [32]byte{},
-			LastAppCommitHash:      [32]byte{3},
-			LastAppBlockHeight:     3,
-			expectedStoreHeight:    3,
-			expectedStateAppHash:   [32]byte{3},
+			name:                 "ProduceThirdBlockSuccessfully",
+			shoudFailOnSaveState: false,
+			LastAppCommitHash:    [32]byte{3},
+			LastAppBlockHeight:   3,
+			expectedStoreHeight:  3,
+			expectedStateAppHash: [32]byte{3},
 		},
 	}
 	for _, tc := range cases {
@@ -304,14 +292,13 @@ func TestProduceBlockFailAfterCommit(t *testing.T) {
 				LastBlockHeight:  tc.LastAppBlockHeight,
 				LastBlockAppHash: tc.LastAppCommitHash[:],
 			})
-			mockStore.ShouldFailSetHeight = tc.shouldFailSetSetHeight
-			mockStore.ShoudFailUpdateState = tc.shouldFailUpdateState
+			mockStore.ShoudFailSaveState = tc.shoudFailOnSaveState
 			_, _, _ = manager.ProduceAndGossipBlock(context.Background(), true)
-			require.Equal(tc.expectedStoreHeight, manager.Store.Height(), tc.name)
-			require.Equal(tc.expectedStateAppHash, manager.LastState.AppHash, tc.name)
 			storeState, err := manager.Store.LoadState()
-			require.NoError(err)
-			require.Equal(tc.expectedStateAppHash, storeState.AppHash, tc.name)
+			assert.NoError(err)
+			manager.State = storeState
+			assert.Equal(tc.expectedStoreHeight, storeState.Height(), tc.name)
+			assert.Equal(tc.expectedStateAppHash, storeState.AppHash, tc.name)
 
 			app.On("Commit", mock.Anything).Unset()
 			app.On("Info", mock.Anything).Unset()
diff --git a/block/produce.go b/block/produce.go
index c3328392c..a68823d9b 100644
--- a/block/produce.go
+++ b/block/produce.go
@@ -87,33 +87,27 @@ func (m *Manager) ProduceAndGossipBlock(ctx context.Context, allowEmpty bool) (*
 	return block, commit, nil
 }
 
+func loadPrevBlock(store store.Store, height uint64) ([32]byte, *types.Commit, error) {
+	lastCommit, err := store.LoadCommit(height)
+	if err != nil {
+		return [32]byte{}, nil, fmt.Errorf("load commit: height: %d: %w", height, err)
+	}
+	lastBlock, err := store.LoadBlock(height)
+	if err != nil {
+		return [32]byte{}, nil, fmt.Errorf("load block after load commit: height: %d: %w", height, err)
+	}
+	return lastBlock.Header.Hash(), lastCommit, nil
+}
+
 func (m *Manager) produceBlock(allowEmpty bool) (*types.Block, *types.Commit, error) {
-	var (
-		lastCommit     *types.Commit
-		lastHeaderHash [32]byte
-		newHeight      uint64
-		err            error
-	)
-
-	if m.LastState.IsGenesis() {
-		newHeight = uint64(m.LastState.InitialHeight)
-		lastCommit = &types.Commit{}
-		m.LastState.BaseHeight = newHeight
-		if ok := m.Store.SetBase(newHeight); !ok {
-			return nil, nil, fmt.Errorf("store set base: %d", newHeight)
-		}
-	} else {
-		height := m.Store.Height()
-		newHeight = height + 1
-		lastCommit, err = m.Store.LoadCommit(height)
-		if err != nil {
-			return nil, nil, fmt.Errorf("load commit: height: %d: %w: %w", height, err, ErrNonRecoverable)
-		}
-		lastBlock, err := m.Store.LoadBlock(height)
-		if err != nil {
-			return nil, nil, fmt.Errorf("load block after load commit: height: %d: %w: %w", height, err, ErrNonRecoverable)
+	newHeight := m.State.NextHeight()
+	lastHeaderHash, lastCommit, err := loadPrevBlock(m.Store, newHeight-1)
+	if err != nil {
+		if !m.State.IsGenesis() { // allow prevBlock not to be found only on genesis
+			return nil, nil, fmt.Errorf("load prev block: %w: %w", err, ErrNonRecoverable)
 		}
-		lastHeaderHash = lastBlock.Header.Hash()
+		lastHeaderHash = [32]byte{}
+		lastCommit = &types.Commit{}
 	}
 
 	var block *types.Block
@@ -132,7 +126,7 @@ func (m *Manager) produceBlock(allowEmpty bool) (*types.Block, *types.Commit, er
 	} else if !errors.Is(err, store.ErrKeyNotFound) {
 		return nil, nil, fmt.Errorf("load block: height: %d: %w: %w", newHeight, err, ErrNonRecoverable)
 	} else {
-		block = m.Executor.CreateBlock(newHeight, lastCommit, lastHeaderHash, m.LastState, m.Conf.BlockBatchMaxSizeBytes)
+		block = m.Executor.CreateBlock(newHeight, lastCommit, lastHeaderHash, m.State, m.Conf.BlockBatchMaxSizeBytes)
 		if !allowEmpty && len(block.Data.Txs) == 0 {
 			return nil, nil, fmt.Errorf("%w: %w", types.ErrSkippedEmptyBlock, ErrRecoverable)
 		}
@@ -192,19 +186,20 @@ func (m *Manager) createTMSignature(block *types.Block, proposerAddress []byte,
 	}
 	v := vote.ToProto()
 	// convert libp2p key to tm key
+	// TODO: move to types
 	raw_key, _ := m.ProposerKey.Raw()
 	tmprivkey := tmed25519.PrivKey(raw_key)
 	tmprivkey.PubKey().Bytes()
 	// Create a mock validator to sign the vote
 	tmvalidator := tmtypes.NewMockPVWithParams(tmprivkey, false, false)
-	err := tmvalidator.SignVote(m.LastState.ChainID, v)
+	err := tmvalidator.SignVote(m.State.ChainID, v)
 	if err != nil {
 		return nil, err
 	}
 	// Update the vote with the signature
 	vote.Signature = v.Signature
 	pubKey := tmprivkey.PubKey()
-	voteSignBytes := tmtypes.VoteSignBytes(m.LastState.ChainID, v)
+	voteSignBytes := tmtypes.VoteSignBytes(m.State.ChainID, v)
 	if !pubKey.VerifySignature(voteSignBytes, vote.Signature) {
 		return nil, fmt.Errorf("wrong signature")
 	}
diff --git a/block/production_test.go b/block/production_test.go
index 3679f684d..bc7c44a9b 100644
--- a/block/production_test.go
+++ b/block/production_test.go
@@ -53,7 +53,7 @@ func TestCreateEmptyBlocksEnableDisable(t *testing.T) {
 
 	// Check initial height
 	initialHeight := uint64(0)
-	require.Equal(initialHeight, manager.Store.Height())
+	require.Equal(initialHeight, manager.State.Height())
 
 	mCtx, cancel := context.WithTimeout(context.Background(), runTime)
 	defer cancel()
@@ -66,15 +66,15 @@ func TestCreateEmptyBlocksEnableDisable(t *testing.T) {
 	go managerWithEmptyBlocks.AccumulatedDataLoop(mCtx, buf2)
 	<-mCtx.Done()
 
-	require.Greater(manager.Store.Height(), initialHeight)
-	require.Greater(managerWithEmptyBlocks.Store.Height(), initialHeight)
-	assert.Greater(managerWithEmptyBlocks.Store.Height(), manager.Store.Height())
+	require.Greater(manager.State.Height(), initialHeight)
+	require.Greater(managerWithEmptyBlocks.State.Height(), initialHeight)
+	assert.Greater(managerWithEmptyBlocks.State.Height(), manager.State.Height())
 
 	// Check that blocks are created with empty blocks feature disabled
-	assert.LessOrEqual(manager.Store.Height(), uint64(runTime/MaxIdleTime))
-	assert.LessOrEqual(managerWithEmptyBlocks.Store.Height(), uint64(runTime/blockTime))
+	assert.LessOrEqual(manager.State.Height(), uint64(runTime/MaxIdleTime))
+	assert.LessOrEqual(managerWithEmptyBlocks.State.Height(), uint64(runTime/blockTime))
 
-	for i := uint64(2); i < managerWithEmptyBlocks.Store.Height(); i++ {
+	for i := uint64(2); i < managerWithEmptyBlocks.State.Height(); i++ {
 		prevBlock, err := managerWithEmptyBlocks.Store.LoadBlock(i - 1)
 		assert.NoError(err)
 
@@ -87,7 +87,7 @@ func TestCreateEmptyBlocksEnableDisable(t *testing.T) {
 		assert.Less(diff, blockTime+blockTime/10)
 	}
 
-	for i := uint64(2); i < manager.Store.Height(); i++ {
+	for i := uint64(2); i < manager.State.Height(); i++ {
 		prevBlock, err := manager.Store.LoadBlock(i - 1)
 		assert.NoError(err)
 
@@ -139,7 +139,7 @@ func TestCreateEmptyBlocksNew(t *testing.T) {
 
 	// Check initial height
 	expectedHeight := uint64(0)
-	assert.Equal(expectedHeight, manager.Store.Height())
+	assert.Equal(expectedHeight, manager.State.Height())
 
 	mCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
@@ -151,8 +151,8 @@ func TestCreateEmptyBlocksNew(t *testing.T) {
 
 	<-mCtx.Done()
 	foundTx := false
-	assert.LessOrEqual(manager.Store.Height(), uint64(10))
-	for i := uint64(2); i < manager.Store.Height(); i++ {
+	assert.LessOrEqual(manager.State.Height(), uint64(10))
+	for i := uint64(2); i < manager.State.Height(); i++ {
 		prevBlock, err := manager.Store.LoadBlock(i - 1)
 		assert.NoError(err)
 
@@ -188,7 +188,7 @@ func TestStopBlockProduction(t *testing.T) {
 
 	// validate initial accumulated is zero
 	require.Equal(manager.AccumulatedBatchSize.Load(), uint64(0))
-	assert.Equal(manager.Store.Height(), uint64(0))
+	assert.Equal(manager.State.Height(), uint64(0))
 
 	// subscribe to health status event
 	eventReceivedCh := make(chan error)
@@ -216,7 +216,7 @@ func TestStopBlockProduction(t *testing.T) {
 
 	// validate block production works
 	time.Sleep(400 * time.Millisecond)
-	assert.Greater(manager.Store.Height(), uint64(0))
+	assert.Greater(manager.State.Height(), uint64(0))
 	assert.Greater(manager.AccumulatedBatchSize.Load(), uint64(0))
 
 	// we don't read from the submit channel, so we assume it get full
@@ -228,11 +228,11 @@ func TestStopBlockProduction(t *testing.T) {
 		assert.Error(err)
 	}
 
-	stoppedHeight := manager.Store.Height()
+	stoppedHeight := manager.State.Height()
 
 	// make sure block production is stopped
 	time.Sleep(400 * time.Millisecond)
-	assert.Equal(stoppedHeight, manager.Store.Height())
+	assert.Equal(stoppedHeight, manager.State.Height())
 
 	// consume the signal
 	<-toSubmit
@@ -247,5 +247,5 @@ func TestStopBlockProduction(t *testing.T) {
 
 	// make sure block production is resumed
 	time.Sleep(400 * time.Millisecond)
-	assert.Greater(manager.Store.Height(), stoppedHeight)
+	assert.Greater(manager.State.Height(), stoppedHeight)
 }
diff --git a/block/pruning.go b/block/pruning.go
index 525e89840..70977cfc9 100644
--- a/block/pruning.go
+++ b/block/pruning.go
@@ -4,19 +4,26 @@ import (
 	"fmt"
 )
 
-func (m *Manager) pruneBlocks(retainHeight int64) (uint64, error) {
+func (m *Manager) pruneBlocks(retainHeight uint64) (uint64, error) {
 	syncTarget := m.SyncTarget.Load()
 
-	if retainHeight > int64(syncTarget) {
+	if retainHeight > syncTarget {
 		return 0, fmt.Errorf("cannot prune uncommitted blocks")
 	}
 
-	pruned, err := m.Store.PruneBlocks(retainHeight)
+	pruned, err := m.Store.PruneBlocks(m.State.BaseHeight, retainHeight)
 	if err != nil {
 		return 0, fmt.Errorf("prune block store: %w", err)
 	}
 
 	// TODO: prune state/indexer and state/txindexer??
 
+	m.State.BaseHeight = retainHeight
+	_, err = m.Store.SaveState(m.State, nil)
+	if err != nil {
+		return 0, fmt.Errorf("save state: %w", err)
+	}
+
+	m.logger.Info("pruned blocks", "pruned", pruned, "retain_height", retainHeight)
 	return pruned, nil
 }
diff --git a/block/retriever.go b/block/retriever.go
index a144089c0..240d1a902 100644
--- a/block/retriever.go
+++ b/block/retriever.go
@@ -37,7 +37,7 @@ func (m *Manager) RetrieveLoop(ctx context.Context) {
 // It fetches the batches from the settlement, gets the DA height and gets
 // the actual blocks from the DA.
 func (m *Manager) syncUntilTarget(targetHeight uint64) error {
-	for currH := m.Store.Height(); currH < targetHeight; currH = m.Store.Height() {
+	for currH := m.State.Height(); currH < targetHeight; currH = m.State.Height() {
 
 		// It's important that we query the state index before fetching the batch, rather
 		// than e.g. keep it and increment it, because we might be concurrently applying blocks
@@ -61,7 +61,7 @@ func (m *Manager) syncUntilTarget(targetHeight uint64) error {
 
 	}
 
-	m.logger.Info("Synced", "store height", m.Store.Height(), "target height", targetHeight)
+	m.logger.Info("Synced", "store height", m.State.Height(), "target height", targetHeight)
 
 	err := m.attemptApplyCachedBlocks()
 	if err != nil {
@@ -76,7 +76,7 @@ func (m *Manager) queryStateIndex() (uint64, error) {
 	var stateIndex uint64
 	return stateIndex, retry.Do(
 		func() error {
-			res, err := m.SLClient.GetHeightState(m.Store.Height() + 1)
+			res, err := m.SLClient.GetHeightState(m.State.NextHeight())
 			if err != nil {
 				m.logger.Debug("sl client get height state", "error", err)
 				return err
@@ -106,7 +106,7 @@ func (m *Manager) ProcessNextDABatch(daMetaData *da.DASubmitMetaData) error {
 
 	for _, batch := range batchResp.Batches {
 		for i, block := range batch.Blocks {
-			if block.Header.Height != m.Store.NextHeight() {
+			if block.Header.Height != m.State.NextHeight() {
 				continue
 			}
 			if err := m.validateBlock(block, batch.Commits[i]); err != nil {
diff --git a/block/state.go b/block/state.go
index 6c5770b65..35ca63c3d 100644
--- a/block/state.go
+++ b/block/state.go
@@ -1,7 +1,10 @@
 package block
 
 import (
-	"time"
+	"errors"
+	"fmt"
+
+	errorsmod "cosmossdk.io/errors"
 
 	"github.com/cometbft/cometbft/crypto/merkle"
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -9,57 +12,51 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"
 
 	"github.com/dymensionxyz/dymint/mempool"
+	"github.com/dymensionxyz/dymint/store"
 	"github.com/dymensionxyz/dymint/types"
 )
 
-// TODO: move all those methods from blockExecutor to manager
-func (e *Executor) updateState(state types.State, block *types.Block, abciResponses *tmstate.ABCIResponses, validatorUpdates []*tmtypes.Validator) (types.State, error) {
-	nValSet := state.NextValidators.Copy()
-	lastHeightValSetChanged := state.LastHeightValidatorsChanged
-	// Dymint can work without validators
-	if len(nValSet.Validators) > 0 {
-		if len(validatorUpdates) > 0 {
-			err := nValSet.UpdateWithChangeSet(validatorUpdates)
-			if err != nil {
-				return state, nil
-			}
-			// Change results from this height but only applies to the next next height.
-			lastHeightValSetChanged = int64(block.Header.Height + 1 + 1)
-		}
-
-		// TODO(tzdybal):  right now, it's for backward compatibility, may need to change this
-		nValSet.IncrementProposerPriority(1)
+// getInitialState tries to load lastState from Store, and if it's not available it reads GenesisDoc.
+func getInitialState(store store.Store, genesis *tmtypes.GenesisDoc, logger types.Logger) (*types.State, error) {
+	s, err := store.LoadState()
+	if errors.Is(err, types.ErrNoStateFound) {
+		logger.Info("failed to find state in the store, creating new state from genesis")
+		s, err = types.NewStateFromGenesis(genesis)
 	}
 
-	hash := block.Header.Hash()
-	// TODO: we can probably pass the state as a pointer and update it directly
-	s := types.State{
-		Version:         state.Version,
-		ChainID:         state.ChainID,
-		InitialHeight:   state.InitialHeight,
-		LastBlockHeight: int64(block.Header.Height),
-		LastBlockTime:   time.Unix(0, int64(block.Header.Time)),
-		LastBlockID: tmtypes.BlockID{
-			Hash: hash[:],
-			// for now, we don't care about part set headers
-		},
-		NextValidators:                   nValSet,
-		Validators:                       state.NextValidators.Copy(),
-		LastHeightValidatorsChanged:      lastHeightValSetChanged,
-		ConsensusParams:                  state.ConsensusParams,
-		LastHeightConsensusParamsChanged: state.LastHeightConsensusParamsChanged,
-		// We're gonna update those fields only after we commit the blocks
-		AppHash:         state.AppHash,
-		LastValidators:  state.LastValidators.Copy(),
-		LastStoreHeight: state.LastStoreHeight,
-
-		LastResultsHash: state.LastResultsHash,
-		BaseHeight:      state.BaseHeight,
+	if err != nil {
+		return nil, fmt.Errorf("get initial state: %w", err)
 	}
 
 	return s, nil
 }
 
+// UpdateStateFromApp is responsible for aligning the state of the store from the abci app
+func (m *Manager) UpdateStateFromApp() error {
+	proxyAppInfo, err := m.Executor.GetAppInfo()
+	if err != nil {
+		return errorsmod.Wrap(err, "get app info")
+	}
+
+	appHeight := uint64(proxyAppInfo.LastBlockHeight)
+	resp, err := m.Store.LoadBlockResponses(appHeight)
+	if err != nil {
+		return errorsmod.Wrap(err, "load block responses")
+	}
+	vals, err := m.Store.LoadValidators(appHeight)
+	if err != nil {
+		return errorsmod.Wrap(err, "load block responses")
+	}
+
+	// update the state with the hash, last store height and last validators.
+	m.Executor.UpdateStateAfterCommit(m.State, resp, proxyAppInfo.LastBlockAppHash, appHeight, vals)
+	_, err = m.Store.SaveState(m.State, nil)
+	if err != nil {
+		return errorsmod.Wrap(err, "update state")
+	}
+	return nil
+}
+
 func (e *Executor) UpdateStateAfterInitChain(s *types.State, res *abci.ResponseInitChain, validators []*tmtypes.Validator) {
 	// If the app did not return an app hash, we keep the one set from the genesis doc in
 	// the state. We don't set appHash since we don't want the genesis doc app hash
@@ -100,7 +97,6 @@ func (e *Executor) UpdateStateAfterInitChain(s *types.State, res *abci.ResponseI
 	// Set the validators in the state
 	s.Validators = tmtypes.NewValidatorSet(validators).CopyIncrementProposerPriority(1)
 	s.NextValidators = s.Validators.Copy()
-	s.LastValidators = s.Validators.Copy()
 }
 
 func (e *Executor) UpdateMempoolAfterInitChain(s *types.State) {
@@ -108,20 +104,22 @@ func (e *Executor) UpdateMempoolAfterInitChain(s *types.State) {
 	e.mempool.SetPostCheckFn(mempool.PostCheckMaxGas(s.ConsensusParams.Block.MaxGas))
 }
 
-// UpdateStateFromResponses updates state based on the ABCIResponses.
-func (e *Executor) UpdateStateFromResponses(resp *tmstate.ABCIResponses, state types.State, block *types.Block) (types.State, error) {
+// NextValSetFromResponses updates state based on the ABCIResponses.
+func (e *Executor) NextValSetFromResponses(state *types.State, resp *tmstate.ABCIResponses, block *types.Block) (*tmtypes.ValidatorSet, error) {
 	// Dymint ignores any setValidator responses from the app, as it is manages the validator set based on the settlement consensus
 	// TODO: this will be changed when supporting multiple sequencers from the hub
-	validatorUpdates := []*tmtypes.Validator{}
+	return state.NextValidators.Copy(), nil
+}
 
-	if state.ConsensusParams.Block.MaxBytes == 0 {
-		e.logger.Error("maxBytes=0", "state.ConsensusParams.Block", state.ConsensusParams.Block)
-	}
+// Update state from Commit response
+func (e *Executor) UpdateStateAfterCommit(s *types.State, resp *tmstate.ABCIResponses, appHash []byte, height uint64, valSet *tmtypes.ValidatorSet) {
+	copy(s.AppHash[:], appHash[:])
+	copy(s.LastResultsHash[:], tmtypes.NewResults(resp.DeliverTxs).Hash())
 
-	state, err := e.updateState(state, block, resp, validatorUpdates)
-	if err != nil {
-		return types.State{}, err
-	}
+	// TODO: load consensus params from endblock?
+
+	s.Validators = s.NextValidators.Copy()
+	s.NextValidators = valSet.Copy()
 
-	return state, nil
+	s.SetHeight(height)
 }
diff --git a/block/submit.go b/block/submit.go
index 5110a8dff..f676795cc 100644
--- a/block/submit.go
+++ b/block/submit.go
@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/dymensionxyz/dymint/gerr"
-
 	"github.com/dymensionxyz/dymint/da"
+	"github.com/dymensionxyz/dymint/gerr"
 	"github.com/dymensionxyz/dymint/node/events"
 	"github.com/dymensionxyz/dymint/types"
 	uevent "github.com/dymensionxyz/dymint/utils/event"
@@ -113,7 +112,7 @@ func (m *Manager) HandleSubmissionTrigger() error {
 	// Load current sync target and height to determine if new blocks are available for submission.
 
 	startHeight := m.SyncTarget.Load() + 1
-	endHeightInclusive := m.Store.Height()
+	endHeightInclusive := m.State.Height()
 
 	if endHeightInclusive < startHeight {
 		return nil // No new blocks have been produced
diff --git a/block/submit_test.go b/block/submit_test.go
index b067d49e7..881644f65 100644
--- a/block/submit_test.go
+++ b/block/submit_test.go
@@ -38,18 +38,18 @@ func TestBatchSubmissionHappyFlow(t *testing.T) {
 
 	// Check initial assertions
 	initialHeight := uint64(0)
-	require.Zero(manager.Store.Height())
+	require.Zero(manager.State.Height())
 	require.Zero(manager.SyncTarget.Load())
 
 	// Produce block and validate that we produced blocks
 	_, _, err = manager.ProduceAndGossipBlock(ctx, true)
 	require.NoError(err)
-	assert.Greater(t, manager.Store.Height(), initialHeight)
+	assert.Greater(t, manager.State.Height(), initialHeight)
 	assert.Zero(t, manager.SyncTarget.Load())
 
 	// submit and validate sync target
 	manager.HandleSubmissionTrigger()
-	assert.EqualValues(t, manager.Store.Height(), manager.SyncTarget.Load())
+	assert.EqualValues(t, manager.State.Height(), manager.SyncTarget.Load())
 }
 
 func TestBatchSubmissionFailedSubmission(t *testing.T) {
@@ -85,13 +85,13 @@ func TestBatchSubmissionFailedSubmission(t *testing.T) {
 
 	// Check initial assertions
 	initialHeight := uint64(0)
-	require.Zero(manager.Store.Height())
+	require.Zero(manager.State.Height())
 	require.Zero(manager.SyncTarget.Load())
 
 	// Produce block and validate that we produced blocks
 	_, _, err = manager.ProduceAndGossipBlock(ctx, true)
 	require.NoError(err)
-	assert.Greater(t, manager.Store.Height(), initialHeight)
+	assert.Greater(t, manager.State.Height(), initialHeight)
 	assert.Zero(t, manager.SyncTarget.Load())
 
 	// try to submit, we expect failure
@@ -101,7 +101,7 @@ func TestBatchSubmissionFailedSubmission(t *testing.T) {
 	// try to submit again, we expect success
 	mockLayerI.On("SubmitBatch", mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 	manager.HandleSubmissionTrigger()
-	assert.EqualValues(t, manager.Store.Height(), manager.SyncTarget.Load())
+	assert.EqualValues(t, manager.State.Height(), manager.SyncTarget.Load())
 }
 
 // TestSubmissionByTime tests the submission trigger by time
@@ -135,7 +135,7 @@ func TestSubmissionByTime(t *testing.T) {
 
 	// Check initial height
 	initialHeight := uint64(0)
-	require.Equal(initialHeight, manager.Store.Height())
+	require.Equal(initialHeight, manager.State.Height())
 	require.Zero(manager.SyncTarget.Load())
 
 	var wg sync.WaitGroup
@@ -188,7 +188,7 @@ func TestSubmissionByBatchSize(t *testing.T) {
 
 		// validate initial accumulated is zero
 		require.Equal(manager.AccumulatedBatchSize.Load(), uint64(0))
-		assert.Equal(manager.Store.Height(), uint64(0))
+		assert.Equal(manager.State.Height(), uint64(0))
 
 		var wg sync.WaitGroup
 		wg.Add(2) // Add 2 because we have 2 goroutines
@@ -209,7 +209,7 @@ func TestSubmissionByBatchSize(t *testing.T) {
 		// wait for block to be produced but not for submission threshold
 		time.Sleep(200 * time.Millisecond)
 		// assert block produced but nothing submitted yet
-		assert.Greater(manager.Store.Height(), uint64(0))
+		assert.Greater(manager.State.Height(), uint64(0))
 		assert.Greater(manager.AccumulatedBatchSize.Load(), uint64(0))
 		assert.Zero(manager.SyncTarget.Load())
 
diff --git a/block/synctarget.go b/block/synctarget.go
index dfe8c9922..c101fddbf 100644
--- a/block/synctarget.go
+++ b/block/synctarget.go
@@ -25,13 +25,13 @@ func (m *Manager) SyncTargetLoop(ctx context.Context) {
 		case event := <-subscription.Out():
 			eventData, _ := event.Data().(*settlement.EventDataNewBatchAccepted)
 
-			if eventData.EndHeight <= m.Store.Height() {
+			if eventData.EndHeight <= m.State.Height() {
 				m.logger.Debug(
 					"syncTargetLoop: received new settlement batch accepted with batch end height <= current store height, skipping.",
 					"height",
 					eventData.EndHeight,
 					"currentHeight",
-					m.Store.Height(),
+					m.State.Height(),
 				)
 				continue
 			}
diff --git a/block/types.go b/block/types.go
index 3f5744f8f..7dfb02981 100644
--- a/block/types.go
+++ b/block/types.go
@@ -2,6 +2,9 @@ package block
 
 import (
 	"github.com/dymensionxyz/dymint/types"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+	tmcrypto "github.com/tendermint/tendermint/crypto"
 )
 
 // TODO: move to types package
@@ -22,3 +25,11 @@ type CachedBlock struct {
 	Block  *types.Block
 	Commit *types.Commit
 }
+
+func getAddress(key crypto.PrivKey) ([]byte, error) {
+	rawKey, err := key.GetPublic().Raw()
+	if err != nil {
+		return nil, err
+	}
+	return tmcrypto.AddressHash(rawKey), nil
+}
diff --git a/state/indexer/block.go b/indexers/blockindexer/block.go
similarity index 100%
rename from state/indexer/block.go
rename to indexers/blockindexer/block.go
diff --git a/state/indexer/block/kv/kv.go b/indexers/blockindexer/kv/kv.go
similarity index 97%
rename from state/indexer/block/kv/kv.go
rename to indexers/blockindexer/kv/kv.go
index 17fd430ba..dce0c572c 100644
--- a/state/indexer/block/kv/kv.go
+++ b/indexers/blockindexer/kv/kv.go
@@ -12,10 +12,11 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/pubsub/query"
-	"github.com/tendermint/tendermint/types"
 
-	"github.com/dymensionxyz/dymint/state/indexer"
+	indexer "github.com/dymensionxyz/dymint/indexers/blockindexer"
 	"github.com/dymensionxyz/dymint/store"
+
+	tmtypes "github.com/tendermint/tendermint/types"
 )
 
 var _ indexer.BlockIndexer = (*BlockerIndexer)(nil)
@@ -54,7 +55,7 @@ func (idx *BlockerIndexer) Has(height int64) (bool, error) {
 // primary key: encode(block.height | height) => encode(height)
 // BeginBlock events: encode(eventType.eventAttr|eventValue|height|begin_block) => encode(height)
 // EndBlock events: encode(eventType.eventAttr|eventValue|height|end_block) => encode(height)
-func (idx *BlockerIndexer) Index(bh types.EventDataNewBlockHeader) error {
+func (idx *BlockerIndexer) Index(bh tmtypes.EventDataNewBlockHeader) error {
 	batch := idx.store.NewBatch()
 	defer batch.Discard()
 
@@ -255,7 +256,7 @@ LOOP:
 			err        error
 		)
 
-		if qr.Key == types.BlockHeightKey {
+		if qr.Key == tmtypes.BlockHeightKey {
 			eventValue, err = parseValueFromPrimaryKey(it.Key())
 		} else {
 			eventValue, err = parseValueFromEventKey(it.Key())
@@ -495,7 +496,7 @@ func (idx *BlockerIndexer) indexEvents(batch store.Batch, events []abci.Event, t
 
 			// index iff the event specified index:true and it's not a reserved event
 			compositeKey := fmt.Sprintf("%s.%s", event.Type, string(attr.Key))
-			if compositeKey == types.BlockHeightKey {
+			if compositeKey == tmtypes.BlockHeightKey {
 				return fmt.Errorf("event type and attribute key \"%s\" is reserved; please use a different key", compositeKey)
 			}
 
diff --git a/state/indexer/block/kv/kv_test.go b/indexers/blockindexer/kv/kv_test.go
similarity index 97%
rename from state/indexer/block/kv/kv_test.go
rename to indexers/blockindexer/kv/kv_test.go
index a44abff88..55bb88539 100644
--- a/state/indexer/block/kv/kv_test.go
+++ b/indexers/blockindexer/kv/kv_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/tendermint/tendermint/libs/pubsub/query"
 	"github.com/tendermint/tendermint/types"
 
-	blockidxkv "github.com/dymensionxyz/dymint/state/indexer/block/kv"
+	blockidxkv "github.com/dymensionxyz/dymint/indexers/blockindexer/kv"
 	"github.com/dymensionxyz/dymint/store"
 )
 
diff --git a/state/indexer/block/kv/util.go b/indexers/blockindexer/kv/util.go
similarity index 100%
rename from state/indexer/block/kv/util.go
rename to indexers/blockindexer/kv/util.go
diff --git a/state/indexer/block/null/null.go b/indexers/blockindexer/null/null.go
similarity index 90%
rename from state/indexer/block/null/null.go
rename to indexers/blockindexer/null/null.go
index 3f4f65e6f..62658e00e 100644
--- a/state/indexer/block/null/null.go
+++ b/indexers/blockindexer/null/null.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"errors"
 
-	"github.com/dymensionxyz/dymint/state/indexer"
+	indexer "github.com/dymensionxyz/dymint/indexers/blockindexer"
 	"github.com/tendermint/tendermint/libs/pubsub/query"
 	"github.com/tendermint/tendermint/types"
 )
diff --git a/state/indexer/query_range.go b/indexers/blockindexer/query_range.go
similarity index 100%
rename from state/indexer/query_range.go
rename to indexers/blockindexer/query_range.go
diff --git a/state/txindex/indexer.go b/indexers/txindex/indexer.go
similarity index 95%
rename from state/txindex/indexer.go
rename to indexers/txindex/indexer.go
index 388d47c18..6d9f6807d 100644
--- a/state/txindex/indexer.go
+++ b/indexers/txindex/indexer.go
@@ -8,8 +8,6 @@ import (
 	"github.com/tendermint/tendermint/libs/pubsub/query"
 )
 
-// XXX/TODO: These types should be moved to the indexer package.
-
 // TxIndexer interface defines methods to index and search transactions.
 type TxIndexer interface {
 	// AddBatch analyzes, indexes and stores a batch of transactions.
diff --git a/state/txindex/indexer_service.go b/indexers/txindex/indexer_service.go
similarity index 95%
rename from state/txindex/indexer_service.go
rename to indexers/txindex/indexer_service.go
index b54efdcf9..0a619e758 100644
--- a/state/txindex/indexer_service.go
+++ b/indexers/txindex/indexer_service.go
@@ -3,7 +3,7 @@ package txindex
 import (
 	"context"
 
-	"github.com/dymensionxyz/dymint/state/indexer"
+	indexer "github.com/dymensionxyz/dymint/indexers/blockindexer"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/types"
 )
@@ -57,7 +57,7 @@ func (is *IndexerService) OnStart() error {
 	go func() {
 		for {
 			msg := <-blockHeadersSub.Out()
-			eventDataHeader := msg.Data().(types.EventDataNewBlockHeader)
+			eventDataHeader, _ := msg.Data().(types.EventDataNewBlockHeader)
 			height := eventDataHeader.Header.Height
 			batch := NewBatch(eventDataHeader.NumTxs)
 
diff --git a/state/txindex/indexer_service_test.go b/indexers/txindex/indexer_service_test.go
similarity index 91%
rename from state/txindex/indexer_service_test.go
rename to indexers/txindex/indexer_service_test.go
index dcac5fb99..3f68eb23b 100644
--- a/state/txindex/indexer_service_test.go
+++ b/indexers/txindex/indexer_service_test.go
@@ -9,9 +9,9 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/types"
 
-	blockidxkv "github.com/dymensionxyz/dymint/state/indexer/block/kv"
-	"github.com/dymensionxyz/dymint/state/txindex"
-	"github.com/dymensionxyz/dymint/state/txindex/kv"
+	blockidxkv "github.com/dymensionxyz/dymint/indexers/blockindexer/kv"
+	"github.com/dymensionxyz/dymint/indexers/txindex"
+	"github.com/dymensionxyz/dymint/indexers/txindex/kv"
 	"github.com/dymensionxyz/dymint/store"
 )
 
diff --git a/state/txindex/kv/kv.go b/indexers/txindex/kv/kv.go
similarity index 97%
rename from state/txindex/kv/kv.go
rename to indexers/txindex/kv/kv.go
index 85ddf8169..03c926ede 100644
--- a/state/txindex/kv/kv.go
+++ b/indexers/txindex/kv/kv.go
@@ -12,11 +12,12 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/pubsub/query"
-	"github.com/tendermint/tendermint/types"
+	tmtypes "github.com/tendermint/tendermint/types"
 
-	"github.com/dymensionxyz/dymint/state/indexer"
-	"github.com/dymensionxyz/dymint/state/txindex"
+	indexer "github.com/dymensionxyz/dymint/indexers/blockindexer"
+	"github.com/dymensionxyz/dymint/indexers/txindex"
 	"github.com/dymensionxyz/dymint/store"
+	"github.com/dymensionxyz/dymint/types"
 )
 
 const (
@@ -282,7 +283,7 @@ func (txi *TxIndex) Search(ctx context.Context, q *query.Query) ([]*abci.TxResul
 
 func lookForHash(conditions []query.Condition) (hash []byte, ok bool, err error) {
 	for _, c := range conditions {
-		if c.CompositeKey == types.TxHashKey {
+		if c.CompositeKey == tmtypes.TxHashKey {
 			decoded, err := hex.DecodeString(c.Operand.(string))
 			return decoded, true, err
 		}
@@ -293,7 +294,7 @@ func lookForHash(conditions []query.Condition) (hash []byte, ok bool, err error)
 // lookForHeight returns a height if there is an "height=X" condition.
 func lookForHeight(conditions []query.Condition) (height int64) {
 	for _, c := range conditions {
-		if c.CompositeKey == types.TxHeightKey && c.Op == query.OpEqual {
+		if c.CompositeKey == tmtypes.TxHeightKey && c.Op == query.OpEqual {
 			return c.Operand.(int64)
 		}
 	}
@@ -574,7 +575,7 @@ func keyForEvent(key string, value []byte, result *abci.TxResult) []byte {
 
 func keyForHeight(result *abci.TxResult) []byte {
 	return []byte(fmt.Sprintf("%s/%d/%d/%d",
-		types.TxHeightKey,
+		tmtypes.TxHeightKey,
 		result.Height,
 		result.Height,
 		result.Index,
diff --git a/state/txindex/kv/kv_bench_test.go b/indexers/txindex/kv/kv_bench_test.go
similarity index 100%
rename from state/txindex/kv/kv_bench_test.go
rename to indexers/txindex/kv/kv_bench_test.go
diff --git a/state/txindex/kv/kv_test.go b/indexers/txindex/kv/kv_test.go
similarity index 99%
rename from state/txindex/kv/kv_test.go
rename to indexers/txindex/kv/kv_test.go
index ae8d18853..023bb1f84 100644
--- a/state/txindex/kv/kv_test.go
+++ b/indexers/txindex/kv/kv_test.go
@@ -15,7 +15,7 @@ import (
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/types"
 
-	"github.com/dymensionxyz/dymint/state/txindex"
+	"github.com/dymensionxyz/dymint/indexers/txindex"
 	"github.com/dymensionxyz/dymint/store"
 )
 
diff --git a/state/txindex/kv/utils.go b/indexers/txindex/kv/utils.go
similarity index 100%
rename from state/txindex/kv/utils.go
rename to indexers/txindex/kv/utils.go
diff --git a/state/txindex/kv/utils_test.go b/indexers/txindex/kv/utils_test.go
similarity index 100%
rename from state/txindex/kv/utils_test.go
rename to indexers/txindex/kv/utils_test.go
diff --git a/state/txindex/null/null.go b/indexers/txindex/null/null.go
similarity index 94%
rename from state/txindex/null/null.go
rename to indexers/txindex/null/null.go
index f8f8cba3e..4cf66cbbf 100644
--- a/state/txindex/null/null.go
+++ b/indexers/txindex/null/null.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"errors"
 
-	"github.com/dymensionxyz/dymint/state/txindex"
+	"github.com/dymensionxyz/dymint/indexers/txindex"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/pubsub/query"
 )
diff --git a/mempool/cache.go b/mempool/cache.go
index 3986cd585..78aefa3c4 100644
--- a/mempool/cache.go
+++ b/mempool/cache.go
@@ -76,7 +76,7 @@ func (c *LRUTxCache) Push(tx types.Tx) bool {
 	if c.list.Len() >= c.size {
 		front := c.list.Front()
 		if front != nil {
-			frontKey := front.Value.(types.TxKey)
+			frontKey, _ := front.Value.(types.TxKey)
 			delete(c.cacheMap, frontKey)
 			c.list.Remove(front)
 		}
diff --git a/mempool/v1/mempool.go b/mempool/v1/mempool.go
index f59b7fbdf..308390b3b 100644
--- a/mempool/v1/mempool.go
+++ b/mempool/v1/mempool.go
@@ -206,7 +206,7 @@ func (txmp *TxMempool) CheckTx(tx types.Tx, cb func(*abci.Response), txInfo memp
 		if !txmp.cache.Push(tx) {
 			// If the cached transaction is also in the pool, record its sender.
 			if elt, ok := txmp.txByKey[txKey]; ok {
-				w := elt.Value.(*WrappedTx)
+				w, _ := elt.Value.(*WrappedTx)
 				w.SetPeer(txInfo.SenderID)
 			}
 			return 0, mempool.ErrTxInCache
diff --git a/node/node.go b/node/node.go
index a60ccbe4f..a77c4c376 100644
--- a/node/node.go
+++ b/node/node.go
@@ -22,16 +22,16 @@ import (
 	"github.com/dymensionxyz/dymint/config"
 	"github.com/dymensionxyz/dymint/da"
 	daregistry "github.com/dymensionxyz/dymint/da/registry"
+	indexer "github.com/dymensionxyz/dymint/indexers/blockindexer"
+	blockidxkv "github.com/dymensionxyz/dymint/indexers/blockindexer/kv"
+	"github.com/dymensionxyz/dymint/indexers/txindex"
+	"github.com/dymensionxyz/dymint/indexers/txindex/kv"
 	"github.com/dymensionxyz/dymint/mempool"
 	mempoolv1 "github.com/dymensionxyz/dymint/mempool/v1"
 	nodemempool "github.com/dymensionxyz/dymint/node/mempool"
 	"github.com/dymensionxyz/dymint/p2p"
 	"github.com/dymensionxyz/dymint/settlement"
 	slregistry "github.com/dymensionxyz/dymint/settlement/registry"
-	"github.com/dymensionxyz/dymint/state/indexer"
-	blockidxkv "github.com/dymensionxyz/dymint/state/indexer/block/kv"
-	"github.com/dymensionxyz/dymint/state/txindex"
-	"github.com/dymensionxyz/dymint/state/txindex/kv"
 	"github.com/dymensionxyz/dymint/store"
 )
 
@@ -69,7 +69,7 @@ type Node struct {
 	incomingTxCh chan *p2p.GossipMessage
 
 	Store        store.Store
-	blockManager *block.Manager
+	BlockManager *block.Manager
 	dalc         da.DataAvailabilityLayerClient
 	settlementlc settlement.LayerI
 
@@ -198,7 +198,7 @@ func NewNode(
 		genesis:        genesis,
 		conf:           conf,
 		P2P:            p2pClient,
-		blockManager:   blockManager,
+		BlockManager:   blockManager,
 		dalc:           dalc,
 		settlementlc:   settlementlc,
 		Mempool:        mp,
@@ -271,7 +271,7 @@ func (n *Node) OnStart() error {
 	}()
 
 	// start the block manager
-	err = n.blockManager.Start(n.ctx)
+	err = n.BlockManager.Start(n.ctx)
 	if err != nil {
 		return fmt.Errorf("while starting block manager: %w", err)
 	}
@@ -380,3 +380,7 @@ func (n *Node) startPrometheusServer() error {
 	}
 	return nil
 }
+
+func (n *Node) GetBlockManagerHeight() uint64 {
+	return n.BlockManager.State.Height()
+}
diff --git a/p2p/validator_test.go b/p2p/validator_test.go
index ef7bc806f..31da0b947 100644
--- a/p2p/validator_test.go
+++ b/p2p/validator_test.go
@@ -140,7 +140,7 @@ func TestValidator_BlockValidator(t *testing.T) {
 			state.Validators = tmtypes.NewValidatorSet(nil)
 
 			// Create empty block
-			block := executor.CreateBlock(1, &types.Commit{}, [32]byte{}, state, maxBytes)
+			block := executor.CreateBlock(1, &types.Commit{}, [32]byte{}, &state, maxBytes)
 
 			// Create slclient
 			client := registry.GetClient(registry.Local)
diff --git a/rpc/client/client.go b/rpc/client/client.go
index 5589e7d65..246109564 100644
--- a/rpc/client/client.go
+++ b/rpc/client/client.go
@@ -65,7 +65,7 @@ func NewClient(node *node.Node) *Client {
 
 // ABCIInfo returns basic information about application state.
 func (c *Client) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) {
-	resInfo, err := c.query().InfoSync(proxy.RequestInfo)
+	resInfo, err := c.Query().InfoSync(proxy.RequestInfo)
 	if err != nil {
 		return nil, err
 	}
@@ -79,7 +79,7 @@ func (c *Client) ABCIQuery(ctx context.Context, path string, data tmbytes.HexByt
 
 // ABCIQueryWithOptions queries for data from application.
 func (c *Client) ABCIQueryWithOptions(ctx context.Context, path string, data tmbytes.HexBytes, opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) {
-	resQuery, err := c.query().QuerySync(abci.RequestQuery{
+	resQuery, err := c.Query().QuerySync(abci.RequestQuery{
 		Path:   path,
 		Data:   data,
 		Height: opts.Height,
@@ -313,10 +313,9 @@ func (c *Client) GenesisChunked(context context.Context, id uint) (*ctypes.Resul
 func (c *Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) {
 	const limit int64 = 20
 
-	// Currently blocks are not pruned and are synced linearly so the base height is 0
 	minHeight, maxHeight, err := filterMinMax(
-		0,
-		int64(c.node.Store.Height()),
+		0, // FIXME: we might be pruned
+		int64(c.node.GetBlockManagerHeight()),
 		minHeight,
 		maxHeight,
 		limit)
@@ -341,7 +340,7 @@ func (c *Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64)
 	}
 
 	return &ctypes.ResultBlockchainInfo{
-		LastHeight: int64(c.node.Store.Height()),
+		LastHeight: int64(c.node.GetBlockManagerHeight()),
 		BlockMetas: blocks,
 	}, nil
 }
@@ -468,7 +467,7 @@ func (c *Client) BlockByHash(ctx context.Context, hash []byte) (*ctypes.ResultBl
 func (c *Client) BlockResults(ctx context.Context, height *int64) (*ctypes.ResultBlockResults, error) {
 	var h uint64
 	if height == nil {
-		h = c.node.Store.Height()
+		h = c.node.GetBlockManagerHeight()
 	} else {
 		h = uint64(*height)
 	}
@@ -698,7 +697,7 @@ func (c *Client) BlockSearch(ctx context.Context, query string, page, perPage *i
 
 // Status returns detailed information about current status of the node.
 func (c *Client) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
-	latest, err := c.node.Store.LoadBlock(c.node.Store.Height())
+	latest, err := c.node.Store.LoadBlock(c.node.GetBlockManagerHeight())
 	if err != nil {
 		// TODO(tzdybal): extract error
 		return nil, fmt.Errorf("find latest block: %w", err)
@@ -802,7 +801,7 @@ func (c *Client) UnconfirmedTxs(ctx context.Context, limitPtr *int) (*ctypes.Res
 //
 // If valid, the tx is automatically added to the mempool.
 func (c *Client) CheckTx(ctx context.Context, tx tmtypes.Tx) (*ctypes.ResultCheckTx, error) {
-	res, err := c.mempool().CheckTxSync(abci.RequestCheckTx{Tx: tx})
+	res, err := c.Mempool().CheckTxSync(abci.RequestCheckTx{Tx: tx})
 	if err != nil {
 		return nil, err
 	}
@@ -858,26 +857,26 @@ func (c *Client) resubscribe(subscriber string, q tmpubsub.Query) tmtypes.Subscr
 	}
 }
 
-func (c *Client) consensus() proxy.AppConnConsensus {
+func (c *Client) Consensus() proxy.AppConnConsensus {
 	return c.node.ProxyApp().Consensus()
 }
 
-func (c *Client) mempool() proxy.AppConnMempool {
+func (c *Client) Mempool() proxy.AppConnMempool {
 	return c.node.ProxyApp().Mempool()
 }
 
-func (c *Client) query() proxy.AppConnQuery {
+func (c *Client) Query() proxy.AppConnQuery {
 	return c.node.ProxyApp().Query()
 }
 
-func (c *Client) snapshot() proxy.AppConnSnapshot {
+func (c *Client) Snapshot() proxy.AppConnSnapshot {
 	return c.node.ProxyApp().Snapshot()
 }
 
 func (c *Client) normalizeHeight(height *int64) uint64 {
 	var heightValue uint64
 	if height == nil || *height == 0 {
-		heightValue = c.node.Store.Height()
+		heightValue = c.node.GetBlockManagerHeight()
 	} else {
 		heightValue = uint64(*height)
 	}
diff --git a/rpc/client/client_test.go b/rpc/client/client_test.go
index 2644b8fc0..81dc1fc4a 100644
--- a/rpc/client/client_test.go
+++ b/rpc/client/client_test.go
@@ -1,4 +1,4 @@
-package client
+package client_test
 
 import (
 	"context"
@@ -31,7 +31,9 @@ import (
 	"github.com/dymensionxyz/dymint/mempool"
 	tmmocks "github.com/dymensionxyz/dymint/mocks/github.com/tendermint/tendermint/abci/types"
 	"github.com/dymensionxyz/dymint/node"
+	"github.com/dymensionxyz/dymint/rpc/client"
 	"github.com/dymensionxyz/dymint/settlement"
+	"github.com/dymensionxyz/dymint/testutil"
 	"github.com/dymensionxyz/dymint/types"
 )
 
@@ -47,10 +49,10 @@ func TestConnectionGetters(t *testing.T) {
 	assert := assert.New(t)
 
 	_, rpc := getRPC(t)
-	assert.NotNil(rpc.consensus())
-	assert.NotNil(rpc.mempool())
-	assert.NotNil(rpc.snapshot())
-	assert.NotNil(rpc.query())
+	assert.NotNil(rpc.Consensus())
+	assert.NotNil(rpc.Mempool())
+	assert.NotNil(rpc.Snapshot())
+	assert.NotNil(rpc.Query())
 }
 
 func TestInfo(t *testing.T) {
@@ -129,14 +131,14 @@ func TestGenesisChunked(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	rpc := NewClient(n)
+	rpc := client.NewClient(n)
 
 	var expectedID uint = 2
 	gc, err := rpc.GenesisChunked(context.Background(), expectedID)
 	assert.Error(err)
 	assert.Nil(gc)
 
-	err = rpc.node.Start()
+	err = n.Start()
 	require.NoError(t, err)
 
 	expectedID = 0
@@ -156,11 +158,11 @@ func TestBroadcastTxAsync(t *testing.T) {
 
 	expectedTx := []byte("tx data")
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("CheckTx", abci.RequestCheckTx{Tx: expectedTx}).Return(abci.ResponseCheckTx{})
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(t, err)
 
 	res, err := rpc.BroadcastTxAsync(context.Background(), expectedTx)
@@ -173,7 +175,7 @@ func TestBroadcastTxAsync(t *testing.T) {
 	assert.NotEmpty(res.Hash)
 	mockApp.AssertExpectations(t)
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(t, err)
 }
 
@@ -192,10 +194,10 @@ func TestBroadcastTxSync(t *testing.T) {
 		Codespace: "space",
 	}
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(t, err)
 
 	mockApp.On("CheckTx", abci.RequestCheckTx{Tx: expectedTx}).Return(expectedResponse)
@@ -210,7 +212,7 @@ func TestBroadcastTxSync(t *testing.T) {
 	assert.NotEmpty(res.Hash)
 	mockApp.AssertExpectations(t)
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(t, err)
 }
 
@@ -240,18 +242,18 @@ func TestBroadcastTxCommit(t *testing.T) {
 		Codespace: "space",
 	}
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.BeginBlock(abci.RequestBeginBlock{})
 	mockApp.On("CheckTx", abci.RequestCheckTx{Tx: expectedTx}).Return(expectedCheckResp)
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 	// in order to broadcast, the node must be started
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	go func() {
 		time.Sleep(mockTxProcessingTime)
-		err := rpc.node.EventBus().PublishEventTx(tmtypes.EventDataTx{TxResult: abci.TxResult{
+		err := node.EventBus().PublishEventTx(tmtypes.EventDataTx{TxResult: abci.TxResult{
 			Height: 1,
 			Index:  0,
 			Tx:     expectedTx,
@@ -267,7 +269,7 @@ func TestBroadcastTxCommit(t *testing.T) {
 	assert.Equal(expectedDeliverResp, res.DeliverTx)
 	mockApp.AssertExpectations(t)
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(err)
 }
 
@@ -275,47 +277,47 @@ func TestGetBlock(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("CheckTx", mock.Anything).Return(abci.ResponseCheckTx{})
 	mockApp.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{})
 	mockApp.On("Commit", mock.Anything).Return(abci.ResponseCommit{})
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	block := getRandomBlock(1, 10)
-	_, err = rpc.node.Store.SaveBlock(block, &types.Commit{}, nil)
-	rpc.node.Store.SetHeight(block.Header.Height)
+	_, err = node.Store.SaveBlock(block, &types.Commit{}, nil)
+	node.BlockManager.State.SetHeight(block.Header.Height)
 	require.NoError(err)
 
 	blockResp, err := rpc.Block(context.Background(), nil)
 	require.NoError(err)
 	require.NotNil(blockResp)
-
 	assert.NotNil(blockResp.Block)
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(err)
 }
 
 func TestGetCommit(t *testing.T) {
 	require := require.New(t)
 	assert := assert.New(t)
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
+
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("Commit", mock.Anything).Return(abci.ResponseCommit{})
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
 	blocks := []*types.Block{getRandomBlock(1, 5), getRandomBlock(2, 6), getRandomBlock(3, 8), getRandomBlock(4, 10)}
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	for _, b := range blocks {
-		_, err = rpc.node.Store.SaveBlock(b, &types.Commit{Height: b.Header.Height}, nil)
-		rpc.node.Store.SetHeight(b.Header.Height)
+		_, err = node.Store.SaveBlock(b, &types.Commit{Height: b.Header.Height}, nil)
+		node.BlockManager.State.SetHeight(b.Header.Height)
 		require.NoError(err)
 	}
 	t.Run("Fetch all commits", func(t *testing.T) {
@@ -335,27 +337,28 @@ func TestGetCommit(t *testing.T) {
 		assert.Equal(blocks[3].Header.Height, uint64(commit.Height))
 	})
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(err)
 }
 
 func TestBlockSearch(t *testing.T) {
 	require := require.New(t)
 	assert := assert.New(t)
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
+
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("Commit", mock.Anything).Return(abci.ResponseCommit{})
 
 	heights := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 	for _, h := range heights {
 		block := getRandomBlock(uint64(h), 5)
-		_, err := rpc.node.Store.SaveBlock(block, &types.Commit{
+		_, err := node.Store.SaveBlock(block, &types.Commit{
 			Height:     uint64(h),
 			HeaderHash: block.Header.Hash(),
 		}, nil)
 		require.NoError(err)
 	}
-	indexBlocks(t, rpc, heights)
+	indexBlocks(t, node, heights)
 
 	tests := []struct {
 		query      string
@@ -403,7 +406,7 @@ func TestGetBlockByHash(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("CheckTx", mock.Anything).Return(abci.ResponseCheckTx{})
 	mockApp.On("EndBlock", mock.Anything).Return(abci.ResponseEndBlock{})
@@ -411,11 +414,11 @@ func TestGetBlockByHash(t *testing.T) {
 	mockApp.On("Info", mock.Anything).Return(abci.ResponseInfo{LastBlockHeight: 0, LastBlockAppHash: []byte{0}})
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	block := getRandomBlock(1, 10)
-	_, err = rpc.node.Store.SaveBlock(block, &types.Commit{}, nil)
+	_, err = node.Store.SaveBlock(block, &types.Commit{}, nil)
 	require.NoError(err)
 	abciBlock, err := types.ToABCIBlock(block)
 	require.NoError(err)
@@ -434,7 +437,7 @@ func TestGetBlockByHash(t *testing.T) {
 
 	assert.NotNil(blockResp.Block)
 
-	err = rpc.node.Stop()
+	err = node.Stop()
 	require.NoError(err)
 }
 
@@ -442,7 +445,7 @@ func TestTx(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 
-	mockApp, rpc := getRPCSequencer(t)
+	mockApp, rpc, node := getRPCAndNodeSequencer(t)
 
 	require.NotNil(rpc)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
@@ -453,7 +456,7 @@ func TestTx(t *testing.T) {
 	mockApp.On("Info", mock.Anything).Return(abci.ResponseInfo{LastBlockHeight: 0, LastBlockAppHash: []byte{0}})
 	mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	tx1 := tmtypes.Tx("tx1")
@@ -496,12 +499,12 @@ func TestUnconfirmedTxs(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)
 
-			mockApp, rpc := getRPC(t)
+			mockApp, rpc, node := getRPCAndNode(t)
 			mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 			mockApp.On("CheckTx", mock.Anything).Return(abci.ResponseCheckTx{})
 			mockApp.On("InitChain", mock.Anything).Return(abci.ResponseInitChain{})
 
-			err := rpc.node.Start()
+			err := node.Start()
 			require.NoError(err)
 
 			for _, tx := range c.txs {
@@ -537,11 +540,11 @@ func TestUnconfirmedTxsLimit(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("CheckTx", mock.Anything).Return(abci.ResponseCheckTx{})
 
-	err := rpc.node.Start()
+	err := node.Start()
 	require.NoError(err)
 
 	tx1 := tmtypes.Tx("tx1")
@@ -576,29 +579,29 @@ func TestConsensusState(t *testing.T) {
 
 	resp1, err := rpc.ConsensusState(context.Background())
 	assert.Nil(resp1)
-	assert.ErrorIs(err, ErrConsensusStateNotAvailable)
+	assert.ErrorIs(err, client.ErrConsensusStateNotAvailable)
 
 	resp2, err := rpc.DumpConsensusState(context.Background())
 	assert.Nil(resp2)
-	assert.ErrorIs(err, ErrConsensusStateNotAvailable)
+	assert.ErrorIs(err, client.ErrConsensusStateNotAvailable)
 }
 
 func TestBlockchainInfo(t *testing.T) {
 	require := require.New(t)
 	assert := assert.New(t)
-	mockApp, rpc := getRPC(t)
+	mockApp, rpc, node := getRPCAndNode(t)
 	mockApp.On("BeginBlock", mock.Anything).Return(abci.ResponseBeginBlock{})
 	mockApp.On("Commit", mock.Anything).Return(abci.ResponseCommit{})
 
 	heights := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 	for _, h := range heights {
 		block := getRandomBlock(uint64(h), 5)
-		_, err := rpc.node.Store.SaveBlock(block, &types.Commit{
+		_, err := node.Store.SaveBlock(block, &types.Commit{
 			Height:     uint64(h),
 			HeaderHash: block.Header.Hash(),
 		}, nil)
-		rpc.node.Store.SetHeight(block.Header.Height)
 		require.NoError(err)
+		node.BlockManager.State.SetHeight(block.Header.Height)
 	}
 
 	tests := []struct {
@@ -612,19 +615,19 @@ func TestBlockchainInfo(t *testing.T) {
 			desc: "min = 1 and max = 5",
 			min:  1,
 			max:  5,
-			exp:  []*tmtypes.BlockMeta{getBlockMeta(rpc, 1), getBlockMeta(rpc, 5)},
+			exp:  []*tmtypes.BlockMeta{getBlockMeta(node, 1), getBlockMeta(node, 5)},
 			err:  false,
 		}, {
 			desc: "min height is 0",
 			min:  0,
 			max:  10,
-			exp:  []*tmtypes.BlockMeta{getBlockMeta(rpc, 1), getBlockMeta(rpc, 10)},
+			exp:  []*tmtypes.BlockMeta{getBlockMeta(node, 1), getBlockMeta(node, 10)},
 			err:  false,
 		}, {
 			desc: "max height is out of range",
 			min:  0,
 			max:  15,
-			exp:  []*tmtypes.BlockMeta{getBlockMeta(rpc, 1), getBlockMeta(rpc, 10)},
+			exp:  []*tmtypes.BlockMeta{getBlockMeta(node, 1), getBlockMeta(node, 10)},
 			err:  false,
 		}, {
 			desc: "negative min height",
@@ -724,7 +727,7 @@ func TestValidatorSetHandling(t *testing.T) {
 	require.NoError(err)
 	require.NotNil(node)
 
-	rpc := NewClient(node)
+	rpc := client.NewClient(node)
 	require.NotNil(rpc)
 
 	err = node.Start()
@@ -756,7 +759,7 @@ func getRandomBlock(height uint64, nTxs int) *types.Block {
 	block := &types.Block{
 		Header: types.Header{
 			Height:          height,
-			Version:         types.Version{Block: types.InitStateVersion.Consensus.Block},
+			Version:         types.Version{Block: testutil.BlockVersion},
 			ProposerAddress: getRandomBytes(20),
 		},
 		Data: types.Data{
@@ -799,8 +802,8 @@ func getRandomBytes(n int) []byte {
 	return data
 }
 
-func getBlockMeta(rpc *Client, n int64) *tmtypes.BlockMeta {
-	b, err := rpc.node.Store.LoadBlock(uint64(n))
+func getBlockMeta(node *node.Node, n int64) *tmtypes.BlockMeta {
+	b, err := node.Store.LoadBlock(uint64(n))
 	if err != nil {
 		return nil
 	}
@@ -813,16 +816,21 @@ func getBlockMeta(rpc *Client, n int64) *tmtypes.BlockMeta {
 }
 
 // getRPC returns a mock application and a new RPC client (non-sequencer mode)
-func getRPC(t *testing.T) (*tmmocks.MockApplication, *Client) {
+func getRPC(t *testing.T) (*tmmocks.MockApplication, *client.Client) {
+	app, rpc, _ := getRPCAndNode(t)
+	return app, rpc
+}
+
+func getRPCAndNode(t *testing.T) (*tmmocks.MockApplication, *client.Client, *node.Node) {
 	return getRPCInternal(t, false)
 }
 
-func getRPCSequencer(t *testing.T) (*tmmocks.MockApplication, *Client) {
+func getRPCAndNodeSequencer(t *testing.T) (*tmmocks.MockApplication, *client.Client, *node.Node) {
 	return getRPCInternal(t, true)
 }
 
 // getRPC returns a mock application and a new RPC client (non-sequencer mode)
-func getRPCInternal(t *testing.T, sequencer bool) (*tmmocks.MockApplication, *Client) {
+func getRPCInternal(t *testing.T, sequencer bool) (*tmmocks.MockApplication, *client.Client, *node.Node) {
 	t.Helper()
 	require := require.New(t)
 	app := &tmmocks.MockApplication{}
@@ -877,18 +885,18 @@ func getRPCInternal(t *testing.T, sequencer bool) (*tmmocks.MockApplication, *Cl
 	require.NoError(err)
 	require.NotNil(node)
 
-	rpc := NewClient(node)
+	rpc := client.NewClient(node)
 	require.NotNil(rpc)
 
-	return app, rpc
+	return app, rpc, node
 }
 
 // From state/indexer/block/kv/kv_test
-func indexBlocks(t *testing.T, rpc *Client, heights []int64) {
+func indexBlocks(t *testing.T, node *node.Node, heights []int64) {
 	t.Helper()
 
 	for _, h := range heights {
-		require.NoError(t, rpc.node.BlockIndexer.Index(tmtypes.EventDataNewBlockHeader{
+		require.NoError(t, node.BlockIndexer.Index(tmtypes.EventDataNewBlockHeader{
 			Header: tmtypes.Header{Height: h},
 			ResultBeginBlock: abci.ResponseBeginBlock{
 				Events: []abci.Event{
@@ -1004,7 +1012,7 @@ func TestMempool2Nodes(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
 
-	local := NewClient(node1)
+	local := client.NewClient(node1)
 	require.NotNil(local)
 
 	// broadcast the bad Tx, this should not be propagated or added to the local mempool
diff --git a/store/kv.go b/store/kv.go
index e118d2c0c..7dcab1a4f 100644
--- a/store/kv.go
+++ b/store/kv.go
@@ -6,35 +6,6 @@ import (
 	"github.com/dgraph-io/badger/v3"
 )
 
-// KVStore encapsulates key-value store abstraction, in minimalistic interface.
-//
-// KVStore MUST be thread safe.
-type KVStore interface {
-	Get(key []byte) ([]byte, error)        // Get gets the value for a key.
-	Set(key []byte, value []byte) error    // Set updates the value for a key.
-	Delete(key []byte) error               // Delete deletes a key.
-	NewBatch() Batch                       // NewBatch creates a new batch.
-	PrefixIterator(prefix []byte) Iterator // PrefixIterator creates iterator to traverse given prefix.
-}
-
-// Batch enables batching of transactions.
-type Batch interface {
-	Set(key, value []byte) error // Accumulates KV entries in a transaction.
-	Delete(key []byte) error     // Deletes the given key.
-	Commit() error               // Commits the transaction.
-	Discard()                    // Discards the transaction.
-}
-
-// Iterator enables traversal over a given prefix.
-type Iterator interface {
-	Valid() bool
-	Next()
-	Key() []byte
-	Value() []byte
-	Error() error
-	Discard()
-}
-
 // NewDefaultInMemoryKVStore builds KVStore that works in-memory (without accessing disk).
 func NewDefaultInMemoryKVStore() KVStore {
 	db, err := badger.Open(badger.DefaultOptions("").WithInMemory(true))
diff --git a/store/pruning.go b/store/pruning.go
index 09908ec5a..cebec016e 100644
--- a/store/pruning.go
+++ b/store/pruning.go
@@ -1,39 +1,32 @@
 package store
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // PruneBlocks removes block up to (but not including) a height. It returns number of blocks pruned.
-func (s *DefaultStore) PruneBlocks(heightInt int64) (uint64, error) {
-	if heightInt <= 0 {
-		return 0, fmt.Errorf("height must be greater than 0")
+func (s *DefaultStore) PruneBlocks(from, to uint64) (uint64, error) {
+	if from <= 0 {
+		return 0, fmt.Errorf("from height must be greater than 0")
 	}
 
-	height := uint64(heightInt)
-	if height > s.Height() {
-		return 0, fmt.Errorf("cannot prune beyond the latest height %v", s.height)
-	}
-	base := s.Base()
-	if height < base {
-		return 0, fmt.Errorf("cannot prune to height %v, it is lower than base height %v",
-			height, base)
+	if to <= from {
+		return 0, fmt.Errorf("to height (%d) must be greater than from height (%d)", to, from)
 	}
 
 	pruned := uint64(0)
 	batch := s.db.NewBatch()
 	defer batch.Discard()
 
-	flush := func(batch Batch, base uint64) error {
+	flush := func(batch Batch, height uint64) error {
 		err := batch.Commit()
 		if err != nil {
-			return fmt.Errorf("prune up to height %v: %w", base, err)
-		}
-		if ok := s.SetBase(base); !ok {
-			return fmt.Errorf("set base height: %v", base)
+			return fmt.Errorf("flush batch to disk: height %d: %w", height, err)
 		}
 		return nil
 	}
 
-	for h := base; h < height; h++ {
+	for h := from; h < to; h++ {
 		hash, err := s.loadHashFromIndex(h)
 		if err != nil {
 			continue
@@ -67,7 +60,7 @@ func (s *DefaultStore) PruneBlocks(heightInt int64) (uint64, error) {
 		}
 	}
 
-	err := flush(batch, height)
+	err := flush(batch, to)
 	if err != nil {
 		return 0, err
 	}
diff --git a/store/pruning_test.go b/store/pruning_test.go
index dc719efd7..43dcd774e 100644
--- a/store/pruning_test.go
+++ b/store/pruning_test.go
@@ -12,15 +12,12 @@ import (
 func TestStorePruning(t *testing.T) {
 	t.Parallel()
 
-	pruningHeight := uint64(3)
-
 	cases := []struct {
-		name           string
-		blocks         []*types.Block
-		pruningHeight  uint64
-		expectedBase   uint64
-		expectedHeight uint64
-		shouldError    bool
+		name        string
+		blocks      []*types.Block
+		from        uint64
+		to          uint64
+		shouldError bool
 	}{
 		{"blocks with pruning", []*types.Block{
 			testutil.GetRandomBlock(1, 0),
@@ -28,59 +25,71 @@ func TestStorePruning(t *testing.T) {
 			testutil.GetRandomBlock(3, 0),
 			testutil.GetRandomBlock(4, 0),
 			testutil.GetRandomBlock(5, 0),
-		}, pruningHeight, pruningHeight, 5, false},
+		}, 3, 5, false},
 		{"blocks out of order", []*types.Block{
 			testutil.GetRandomBlock(2, 0),
 			testutil.GetRandomBlock(3, 0),
 			testutil.GetRandomBlock(1, 0),
-		}, pruningHeight, pruningHeight, 3, false},
+			testutil.GetRandomBlock(5, 0),
+		}, 3, 5, false},
 		{"with a gap", []*types.Block{
 			testutil.GetRandomBlock(1, 0),
 			testutil.GetRandomBlock(9, 0),
 			testutil.GetRandomBlock(10, 0),
-		}, pruningHeight, pruningHeight, 10, false},
-		{"pruning beyond latest height", []*types.Block{
+		}, 3, 5, false},
+		{"pruning height 0", []*types.Block{
 			testutil.GetRandomBlock(1, 0),
 			testutil.GetRandomBlock(2, 0),
-		}, pruningHeight, 1, 2, true}, // should error because pruning height > latest height
-		{"pruning height 0", []*types.Block{
+			testutil.GetRandomBlock(3, 0),
+		}, 0, 1, true},
+		{"pruning same height", []*types.Block{
 			testutil.GetRandomBlock(1, 0),
 			testutil.GetRandomBlock(2, 0),
 			testutil.GetRandomBlock(3, 0),
-		}, 0, 1, 3, true},
+		}, 3, 3, true},
 	}
-
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			assert := assert.New(t)
 			bstore := store.New(store.NewDefaultInMemoryKVStore())
-			assert.Equal(uint64(0), bstore.Height())
 
+			savedHeights := make(map[uint64]bool)
 			for _, block := range c.blocks {
 				_, err := bstore.SaveBlock(block, &types.Commit{}, nil)
-				_ = bstore.SetHeight(block.Header.Height)
 				assert.NoError(err)
+				savedHeights[block.Header.Height] = true
+
+				// TODO: add block responses and commits
 			}
 
-			_, err := bstore.PruneBlocks(int64(c.pruningHeight))
+			// Validate all blocks are saved
+			for k := range savedHeights {
+				_, err := bstore.LoadBlock(k)
+				assert.NoError(err)
+			}
+
+			_, err := bstore.PruneBlocks(c.from, c.to)
 			if c.shouldError {
 				assert.Error(err)
-			} else {
-				assert.NoError(err)
-				assert.Equal(pruningHeight, bstore.Base())
-				assert.Equal(c.expectedHeight, bstore.Height())
-				assert.Equal(c.expectedBase, bstore.Base())
+				return
+			}
+
+			assert.NoError(err)
 
-				// Check if pruned blocks are really removed from the store
-				for h := uint64(1); h < pruningHeight; h++ {
-					_, err := bstore.LoadBlock(h)
-					assert.Error(err, "Block at height %d should be pruned", h)
+			// Validate only blocks in the range are pruned
+			for k := range savedHeights {
+				if k >= c.from && k < c.to { // k < c.to is the exclusion test
+					_, err := bstore.LoadBlock(k)
+					assert.Error(err, "Block at height %d should be pruned", k)
 
-					_, err = bstore.LoadBlockResponses(h)
-					assert.Error(err, "BlockResponse at height %d should be pruned", h)
+					_, err = bstore.LoadBlockResponses(k)
+					assert.Error(err, "BlockResponse at height %d should be pruned", k)
 
-					_, err = bstore.LoadCommit(h)
-					assert.Error(err, "Commit at height %d should be pruned", h)
+					_, err = bstore.LoadCommit(k)
+					assert.Error(err, "Commit at height %d should be pruned", k)
+				} else {
+					_, err := bstore.LoadBlock(k)
+					assert.NoError(err)
 				}
 			}
 		})
diff --git a/store/store.go b/store/store.go
index 154369bba..3c206957e 100644
--- a/store/store.go
+++ b/store/store.go
@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"sync/atomic"
 
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
@@ -24,12 +23,9 @@ var (
 	validatorsPrefix = [1]byte{6}
 )
 
-// DefaultStore is a default store implmementation.
+// DefaultStore is a default store implementation.
 type DefaultStore struct {
 	db KVStore
-
-	height     uint64 // the highest block saved
-	baseHeight uint64 // the lowest block saved
 }
 
 var _ Store = &DefaultStore{}
@@ -46,43 +42,6 @@ func (s *DefaultStore) NewBatch() Batch {
 	return s.db.NewBatch()
 }
 
-// SetHeight sets the height saved in the Store if it is higher than the existing height
-// returns OK if the value was updated successfully or did not need to be updated
-func (s *DefaultStore) SetHeight(height uint64) bool {
-	ok := true
-	storeHeight := s.Height()
-	if height > storeHeight {
-		ok = atomic.CompareAndSwapUint64(&s.height, storeHeight, height)
-	}
-	return ok
-}
-
-// Height returns height of the highest block saved in the Store.
-func (s *DefaultStore) Height() uint64 {
-	return atomic.LoadUint64(&s.height)
-}
-
-// NextHeight returns the next height that expected to be stored in store.
-func (s *DefaultStore) NextHeight() uint64 {
-	return s.Height() + 1
-}
-
-// SetBase sets the base height if it is higher than the existing base height
-// returns OK if the value was updated successfully or did not need to be updated
-func (s *DefaultStore) SetBase(height uint64) bool {
-	ok := true
-	baseHeight := s.Base()
-	if height > baseHeight {
-		ok = atomic.CompareAndSwapUint64(&s.baseHeight, baseHeight, height)
-	}
-	return ok
-}
-
-// Base returns height of the earliest block saved in the Store.
-func (s *DefaultStore) Base() uint64 {
-	return atomic.LoadUint64(&s.baseHeight)
-}
-
 // SaveBlock adds block to the store along with corresponding commit.
 // Stored height is updated if block height is greater than stored value.
 // In case a batch is provided, the block and commit are added to the batch and not saved.
@@ -202,7 +161,7 @@ func (s *DefaultStore) LoadCommitByHash(hash [32]byte) (*types.Commit, error) {
 
 // UpdateState updates state saved in Store. Only one State is stored.
 // If there is no State in Store, state will be saved.
-func (s *DefaultStore) UpdateState(state types.State, batch Batch) (Batch, error) {
+func (s *DefaultStore) SaveState(state *types.State, batch Batch) (Batch, error) {
 	pbState, err := state.ToProto()
 	if err != nil {
 		return batch, fmt.Errorf("marshal state to JSON: %w", err)
@@ -220,26 +179,24 @@ func (s *DefaultStore) UpdateState(state types.State, batch Batch) (Batch, error
 }
 
 // LoadState returns last state saved with UpdateState.
-func (s *DefaultStore) LoadState() (types.State, error) {
+func (s *DefaultStore) LoadState() (*types.State, error) {
 	blob, err := s.db.Get(getStateKey())
 	if err != nil {
-		return types.State{}, types.ErrNoStateFound
+		return nil, types.ErrNoStateFound
 	}
 	var pbState pb.State
 	err = pbState.Unmarshal(blob)
 	if err != nil {
-		return types.State{}, fmt.Errorf("unmarshal state from store: %w", err)
+		return nil, fmt.Errorf("unmarshal state from store: %w", err)
 	}
 
 	var state types.State
 	err = state.FromProto(&pbState)
 	if err != nil {
-		return types.State{}, fmt.Errorf("unmarshal state from proto: %w", err)
+		return nil, fmt.Errorf("unmarshal state from proto: %w", err)
 	}
 
-	atomic.StoreUint64(&s.height, state.LastStoreHeight)
-	atomic.StoreUint64(&s.baseHeight, state.BaseHeight)
-	return state, nil
+	return &state, nil
 }
 
 // SaveValidators stores validator set for given block height in store.
diff --git a/store/types.go b/store/storeIface.go
similarity index 60%
rename from store/types.go
rename to store/storeIface.go
index 2a531eaaa..3acb988e6 100644
--- a/store/types.go
+++ b/store/storeIface.go
@@ -1,31 +1,44 @@
 package store
 
 import (
+	"github.com/dymensionxyz/dymint/types"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	tmtypes "github.com/tendermint/tendermint/types"
-
-	"github.com/dymensionxyz/dymint/types"
 )
 
-// Store is minimal interface for storing and retrieving blocks, commits and state.
-type Store interface {
-	// NewBatch creates a new db batch.
-	NewBatch() Batch
-
-	// Height returns height of the highest block in store.
-	Height() uint64
-
-	// NextHeight returns the next height that expected to be stored in store.
-	NextHeight() uint64
+// KVStore encapsulates key-value store abstraction, in minimalistic interface.
+//
+// KVStore MUST be thread safe.
+type KVStore interface {
+	Get(key []byte) ([]byte, error)        // Get gets the value for a key.
+	Set(key []byte, value []byte) error    // Set updates the value for a key.
+	Delete(key []byte) error               // Delete deletes a key.
+	NewBatch() Batch                       // NewBatch creates a new batch.
+	PrefixIterator(prefix []byte) Iterator // PrefixIterator creates iterator to traverse given prefix.
+}
 
-	// SetHeight sets the height saved in the Store if it is higher than the existing height.
-	SetHeight(height uint64) bool
+// Batch enables batching of transactions.
+type Batch interface {
+	Set(key, value []byte) error // Accumulates KV entries in a transaction.
+	Delete(key []byte) error     // Deletes the given key.
+	Commit() error               // Commits the transaction.
+	Discard()                    // Discards the transaction.
+}
 
-	// Base returns height of the lowest block in store.
-	Base() uint64
+// Iterator enables traversal over a given prefix.
+type Iterator interface {
+	Valid() bool
+	Next()
+	Key() []byte
+	Value() []byte
+	Error() error
+	Discard()
+}
 
-	// SetBase sets the height saved in the Store for the lowest block
-	SetBase(height uint64) bool
+// Store is minimal interface for storing and retrieving blocks, commits and state.
+type Store interface {
+	// NewStoreBatch creates a new db batch.
+	NewBatch() Batch
 
 	// SaveBlock saves block along with its seen commit (which will be included in the next block).
 	SaveBlock(block *types.Block, commit *types.Commit, batch Batch) (Batch, error)
@@ -48,15 +61,15 @@ type Store interface {
 
 	// UpdateState updates state saved in Store. Only one State is stored.
 	// If there is no State in Store, state will be saved.
-	UpdateState(state types.State, batch Batch) (Batch, error)
+	SaveState(state *types.State, batch Batch) (Batch, error)
 
 	// LoadState returns last state saved with UpdateState.
-	LoadState() (types.State, error)
+	LoadState() (*types.State, error)
 
 	SaveValidators(height uint64, validatorSet *tmtypes.ValidatorSet, batch Batch) (Batch, error)
 
 	LoadValidators(height uint64) (*tmtypes.ValidatorSet, error)
 
 	// Pruning functions
-	PruneBlocks(height int64) (uint64, error)
+	PruneBlocks(from, to uint64) (uint64, error)
 }
diff --git a/store/store_test.go b/store/store_test.go
index 3241f47f2..40f272391 100644
--- a/store/store_test.go
+++ b/store/store_test.go
@@ -8,53 +8,13 @@ import (
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 
 	"github.com/dymensionxyz/dymint/store"
+
 	"github.com/dymensionxyz/dymint/testutil"
 	"github.com/dymensionxyz/dymint/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestStoreHeight(t *testing.T) {
-	t.Parallel()
-	cases := []struct {
-		name     string
-		blocks   []*types.Block
-		expected uint64
-	}{
-		{"single block", []*types.Block{testutil.GetRandomBlock(1, 0)}, 1},
-		{"two consecutive blocks", []*types.Block{
-			testutil.GetRandomBlock(1, 0),
-			testutil.GetRandomBlock(2, 0),
-		}, 2},
-		{"blocks out of order", []*types.Block{
-			testutil.GetRandomBlock(2, 0),
-			testutil.GetRandomBlock(3, 0),
-			testutil.GetRandomBlock(1, 0),
-		}, 3},
-		{"with a gap", []*types.Block{
-			testutil.GetRandomBlock(1, 0),
-			testutil.GetRandomBlock(9, 0),
-			testutil.GetRandomBlock(10, 0),
-		}, 10},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			assert := assert.New(t)
-			bstore := store.New(store.NewDefaultInMemoryKVStore())
-			assert.Equal(uint64(0), bstore.Height())
-
-			for _, block := range c.blocks {
-				_, err := bstore.SaveBlock(block, &types.Commit{}, nil)
-				_ = bstore.SetHeight(block.Header.Height)
-				assert.NoError(err)
-			}
-
-			assert.Equal(c.expected, bstore.Height())
-		})
-	}
-}
-
 func TestStoreLoad(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
@@ -123,7 +83,7 @@ func TestStoreLoad(t *testing.T) {
 	}
 }
 
-func TestRestart(t *testing.T) {
+func TestLoadState(t *testing.T) {
 	t.Parallel()
 
 	assert := assert.New(t)
@@ -133,20 +93,19 @@ func TestRestart(t *testing.T) {
 	kv := store.NewDefaultInMemoryKVStore()
 	s1 := store.New(kv)
 	expectedHeight := uint64(10)
-	_, err := s1.UpdateState(types.State{
-		LastBlockHeight: int64(expectedHeight),
-		LastStoreHeight: uint64(expectedHeight),
-		NextValidators:  validatorSet,
-		Validators:      validatorSet,
-		LastValidators:  validatorSet,
-	}, nil)
+	s := &types.State{
+		NextValidators: validatorSet,
+		Validators:     validatorSet,
+	}
+	s.LastBlockHeight.Store(expectedHeight)
+	_, err := s1.SaveState(s, nil)
 	assert.NoError(err)
 
 	s2 := store.New(kv)
-	_, err = s2.LoadState()
+	state, err := s2.LoadState()
 	assert.NoError(err)
 
-	assert.Equal(expectedHeight, s2.Height())
+	assert.Equal(expectedHeight, state.LastBlockHeight.Load())
 }
 
 func TestBlockResponses(t *testing.T) {
diff --git a/test/loadtime/cmd/report/main.go b/test/loadtime/cmd/report/main.go
index 605a955cb..2756c9095 100644
--- a/test/loadtime/cmd/report/main.go
+++ b/test/loadtime/cmd/report/main.go
@@ -22,7 +22,13 @@ var mainPrefix = [1]byte{0}
 // BlockStore is a thin wrapper around the DefaultStore which will be used for inspecting the blocks
 type BlockStore struct {
 	*store.DefaultStore
-	base uint64
+	base   uint64
+	height uint64
+}
+
+// Height implements report.BlockStore.
+func (b *BlockStore) Height() uint64 {
+	return b.height
 }
 
 // Base will be used to get the block height of the first block we want to generate the report for
@@ -40,13 +46,14 @@ func getStore(directory string) *store.PrefixKV {
 
 func newBlockStore(kvstore store.KVStore, baseHeight uint64) *BlockStore {
 	store, _ := store.New(kvstore).(*store.DefaultStore)
-	_, err := store.LoadState()
+	state, err := store.LoadState()
 	if err != nil {
 		log.Fatalf("loading state %s", err)
 	}
 	return &BlockStore{
 		DefaultStore: store,
-		base:         baseHeight,
+		base:         state.BaseHeight,
+		height:       state.LastBlockHeight.Load(),
 	}
 }
 
diff --git a/testutil/block.go b/testutil/block.go
index b809b0181..195faa6c0 100644
--- a/testutil/block.go
+++ b/testutil/block.go
@@ -32,7 +32,7 @@ const (
 /* -------------------------------------------------------------------------- */
 /*                                    utils                                   */
 /* -------------------------------------------------------------------------- */
-func GetManagerWithProposerKey(conf config.BlockManagerConfig, proposerKey crypto.PrivKey, settlementlc settlement.LayerI, dalc da.DataAvailabilityLayerClient, genesisHeight int64, storeInitialHeight int64, storeLastBlockHeight int64, proxyAppConns proxy.AppConns, mockStore store.Store) (*block.Manager, error) {
+func GetManagerWithProposerKey(conf config.BlockManagerConfig, proposerKey crypto.PrivKey, settlementlc settlement.LayerI, dalc da.DataAvailabilityLayerClient, genesisHeight, storeInitialHeight, storeLastBlockHeight int64, proxyAppConns proxy.AppConns, mockStore store.Store) (*block.Manager, error) {
 	genesis := GenerateGenesis(genesisHeight)
 	// Change the LastBlockHeight to avoid calling InitChainSync within the manager
 	// And updating the state according to the genesis.
@@ -43,7 +43,7 @@ func GetManagerWithProposerKey(conf config.BlockManagerConfig, proposerKey crypt
 	} else {
 		managerStore = mockStore
 	}
-	if _, err := managerStore.UpdateState(state, nil); err != nil {
+	if _, err := managerStore.SaveState(state, nil); err != nil {
 		return nil, err
 	}
 
@@ -113,7 +113,7 @@ func GetManagerWithProposerKey(conf config.BlockManagerConfig, proposerKey crypt
 	return manager, nil
 }
 
-func GetManager(conf config.BlockManagerConfig, settlementlc settlement.LayerI, dalc da.DataAvailabilityLayerClient, genesisHeight int64, storeInitialHeight int64, storeLastBlockHeight int64, proxyAppConns proxy.AppConns, mockStore store.Store) (*block.Manager, error) {
+func GetManager(conf config.BlockManagerConfig, settlementlc settlement.LayerI, dalc da.DataAvailabilityLayerClient, genesisHeight, storeInitialHeight, storeLastBlockHeight int64, proxyAppConns proxy.AppConns, mockStore store.Store) (*block.Manager, error) {
 	proposerKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
 	if err != nil {
 		return nil, err
diff --git a/testutil/mocks.go b/testutil/mocks.go
index 5f97ee0e3..b4cb09967 100644
--- a/testutil/mocks.go
+++ b/testutil/mocks.go
@@ -90,8 +90,7 @@ func CountMockCalls(totalCalls []mock.Call, methodName string) int {
 
 // MockStore is a mock store for testing
 type MockStore struct {
-	ShouldFailSetHeight            bool
-	ShoudFailUpdateState           bool
+	ShoudFailSaveState             bool
 	ShouldFailUpdateStateWithBatch bool
 	*store.DefaultStore
 	height uint64
@@ -99,12 +98,8 @@ type MockStore struct {
 
 // SetHeight sets the height of the mock store
 // Don't set the height to mock failure in setting the height
-func (m *MockStore) SetHeight(height uint64) bool {
-	if m.ShouldFailSetHeight {
-		return false
-	}
+func (m *MockStore) SetHeight(height uint64) {
 	m.height = height
-	return true
 }
 
 func (m *MockStore) Height() uint64 {
@@ -116,21 +111,20 @@ func (m *MockStore) NextHeight() uint64 {
 }
 
 // UpdateState updates the state of the mock store
-func (m *MockStore) UpdateState(state types.State, batch store.Batch) (store.Batch, error) {
-	if batch != nil && m.ShouldFailUpdateStateWithBatch || m.ShoudFailUpdateState && batch == nil {
+func (m *MockStore) SaveState(state *types.State, batch store.Batch) (store.Batch, error) {
+	if batch != nil && m.ShouldFailUpdateStateWithBatch || m.ShoudFailSaveState && batch == nil {
 		return nil, errors.New("failed to update state")
 	}
-	return m.DefaultStore.UpdateState(state, batch)
+	return m.DefaultStore.SaveState(state, batch)
 }
 
 // NewMockStore returns a new mock store
 func NewMockStore() *MockStore {
 	defaultStore := store.New(store.NewDefaultInMemoryKVStore())
 	return &MockStore{
-		DefaultStore:         defaultStore.(*store.DefaultStore),
-		height:               0,
-		ShouldFailSetHeight:  false,
-		ShoudFailUpdateState: false,
+		DefaultStore:       defaultStore.(*store.DefaultStore),
+		height:             0,
+		ShoudFailSaveState: false,
 	}
 }
 
diff --git a/testutil/types.go b/testutil/types.go
index e5237c5e5..511636ea3 100644
--- a/testutil/types.go
+++ b/testutil/types.go
@@ -66,7 +66,7 @@ func generateBlock(height uint64) *types.Block {
 			ConsensusHash:  h[3],
 			// AppHash:         h[4],
 			AppHash:         [32]byte{},
-			LastResultsHash: getEmptyLastResultsHash(),
+			LastResultsHash: GetEmptyLastResultsHash(),
 			ProposerAddress: []byte{4, 3, 2, 1},
 			SequencersHash:  h[6],
 		},
@@ -193,23 +193,23 @@ func GenerateRandomValidatorSet() *tmtypes.ValidatorSet {
 }
 
 // GenerateState generates an initial state for testing.
-func GenerateState(initialHeight int64, lastBlockHeight int64) types.State {
-	return types.State{
+func GenerateState(initialHeight int64, lastBlockHeight int64) *types.State {
+	s := &types.State{
 		ChainID:         "test-chain",
-		InitialHeight:   initialHeight,
+		InitialHeight:   uint64(initialHeight),
 		AppHash:         [32]byte{},
-		LastResultsHash: getEmptyLastResultsHash(),
+		LastResultsHash: GetEmptyLastResultsHash(),
 		Version: tmstate.Version{
 			Consensus: version.Consensus{
 				Block: BlockVersion,
 				App:   AppVersion,
 			},
 		},
-		LastBlockHeight: lastBlockHeight,
-		LastValidators:  GenerateRandomValidatorSet(),
-		Validators:      GenerateRandomValidatorSet(),
-		NextValidators:  GenerateRandomValidatorSet(),
+		Validators:     GenerateRandomValidatorSet(),
+		NextValidators: GenerateRandomValidatorSet(),
 	}
+	s.LastBlockHeight.Store(uint64(lastBlockHeight))
+	return s
 }
 
 // GenerateGenesis generates a genesis for testing.
@@ -237,7 +237,7 @@ func GenerateGenesis(initialHeight int64) *tmtypes.GenesisDoc {
 	}
 }
 
-func getEmptyLastResultsHash() [32]byte {
+func GetEmptyLastResultsHash() [32]byte {
 	lastResults := []*abci.ResponseDeliverTx{}
 	return *(*[32]byte)(tmtypes.NewResults(lastResults).Hash())
 }
diff --git a/types/serialization.go b/types/serialization.go
index 0e72108e7..0892c946b 100644
--- a/types/serialization.go
+++ b/types/serialization.go
@@ -251,22 +251,14 @@ func (s *State) ToProto() (*pb.State, error) {
 	if err != nil {
 		return nil, err
 	}
-	lastValidators, err := s.LastValidators.ToProto()
-	if err != nil {
-		return nil, err
-	}
 
 	return &pb.State{
 		Version:                          &s.Version,
 		ChainId:                          s.ChainID,
-		InitialHeight:                    s.InitialHeight,
-		LastBlockHeight:                  s.LastBlockHeight,
-		LastBlockID:                      s.LastBlockID.ToProto(),
-		LastBlockTime:                    s.LastBlockTime,
+		InitialHeight:                    int64(s.InitialHeight),
+		LastBlockHeight:                  int64(s.LastBlockHeight.Load()),
 		NextValidators:                   nextValidators,
 		Validators:                       validators,
-		LastValidators:                   lastValidators,
-		LastStoreHeight:                  s.LastStoreHeight,
 		BaseHeight:                       s.BaseHeight,
 		LastHeightValidatorsChanged:      s.LastHeightValidatorsChanged,
 		ConsensusParams:                  s.ConsensusParams,
@@ -281,22 +273,10 @@ func (s *State) FromProto(other *pb.State) error {
 	var err error
 	s.Version = *other.Version
 	s.ChainID = other.ChainId
-	s.InitialHeight = other.InitialHeight
-	s.LastBlockHeight = other.LastBlockHeight
-	// TODO(omritoptix): remove this as this is only for backwards compatibility
-	// with old state files that don't have this field.
-	if other.LastStoreHeight == 0 && other.LastBlockHeight > 1 {
-		s.LastStoreHeight = uint64(other.LastBlockHeight)
-	} else {
-		s.LastStoreHeight = other.LastStoreHeight
-	}
+	s.InitialHeight = uint64(other.InitialHeight)
+	s.LastBlockHeight.Store(uint64(other.LastBlockHeight))
 	s.BaseHeight = other.BaseHeight
-	lastBlockID, err := types.BlockIDFromProto(&other.LastBlockID)
-	if err != nil {
-		return err
-	}
-	s.LastBlockID = *lastBlockID
-	s.LastBlockTime = other.LastBlockTime
+
 	s.NextValidators, err = types.ValidatorSetFromProto(other.NextValidators)
 	if err != nil {
 		return err
@@ -305,10 +285,6 @@ func (s *State) FromProto(other *pb.State) error {
 	if err != nil {
 		return err
 	}
-	s.LastValidators, err = types.ValidatorSetFromProto(other.LastValidators)
-	if err != nil {
-		return err
-	}
 	s.LastHeightValidatorsChanged = other.LastHeightValidatorsChanged
 	s.ConsensusParams = other.ConsensusParams
 	s.LastHeightConsensusParamsChanged = other.LastHeightConsensusParamsChanged
diff --git a/types/serialization_test.go b/types/serialization_test.go
index f6da1ffd0..355aaa95c 100644
--- a/types/serialization_test.go
+++ b/types/serialization_test.go
@@ -3,7 +3,6 @@ package types_test
 import (
 	"crypto/rand"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -98,7 +97,6 @@ func TestStateRoundTrip(t *testing.T) {
 		{
 			"with max bytes",
 			types.State{
-				LastValidators: valSet,
 				Validators:     valSet,
 				NextValidators: valSet,
 				ConsensusParams: tmproto.ConsensusParams{
@@ -120,21 +118,10 @@ func TestStateRoundTrip(t *testing.T) {
 					},
 					Software: "dymint",
 				},
-				ChainID:         "testchain",
-				InitialHeight:   987,
-				LastBlockHeight: 987654321,
-				LastStoreHeight: 987654321,
-				LastBlockID: tmtypes.BlockID{
-					Hash: nil,
-					PartSetHeader: tmtypes.PartSetHeader{
-						Total: 0,
-						Hash:  nil,
-					},
-				},
-				LastBlockTime:               time.Date(2022, 6, 6, 12, 12, 33, 44, time.UTC),
+				ChainID:                     "testchain",
+				InitialHeight:               987,
 				NextValidators:              valSet,
 				Validators:                  valSet,
-				LastValidators:              valSet,
 				LastHeightValidatorsChanged: 8272,
 				ConsensusParams: tmproto.ConsensusParams{
 					Block: tmproto.BlockParams{
@@ -165,6 +152,11 @@ func TestStateRoundTrip(t *testing.T) {
 		t.Run(c.name, func(t *testing.T) {
 			require := require.New(t)
 			assert := assert.New(t)
+
+			if c.state.InitialHeight != 0 {
+				c.state.LastBlockHeight.Store(986321)
+			}
+
 			pState, err := c.state.ToProto()
 			require.NoError(err)
 			require.NotNil(pState)
diff --git a/types/state.go b/types/state.go
index 4715bf034..8e7afc2d0 100644
--- a/types/state.go
+++ b/types/state.go
@@ -2,7 +2,7 @@ package types
 
 import (
 	"fmt"
-	"time"
+	"sync/atomic"
 
 	// TODO(tzdybal): copy to local project?
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
@@ -12,35 +12,22 @@ import (
 	"github.com/tendermint/tendermint/version"
 )
 
-// InitStateVersion sets the Consensus.Block and Software versions,
-// but leaves the Consensus.App version blank.
-// The Consensus.App version will be set during the Handshake, once
-// we hear from the app what protocol version it is running.
-var InitStateVersion = tmstate.Version{
-	Consensus: tmversion.Consensus{
-		Block: version.BlockProtocol,
-		App:   0,
-	},
-	Software: version.TMCoreSemVer,
-}
-
 // State contains information about current state of the blockchain.
 type State struct {
 	Version tmstate.Version
 
 	// immutable
 	ChainID       string
-	InitialHeight int64 // should be 1, not 0, when starting from height 1
+	InitialHeight uint64 // should be 1, not 0, when starting from height 1
 
 	// LastBlockHeight=0 at genesis (ie. block(H=0) does not exist)
-	LastBlockHeight int64
-	LastBlockID     types.BlockID
-	LastBlockTime   time.Time
+	LastBlockHeight atomic.Uint64
+
+	// BaseHeight is the height of the first block we have in store after pruning.
+	BaseHeight uint64
 
-	// In the MVP implementation, there will be only one Validator
 	NextValidators              *types.ValidatorSet
 	Validators                  *types.ValidatorSet
-	LastValidators              *types.ValidatorSet
 	LastHeightValidatorsChanged int64
 
 	// Consensus parameters used for validating blocks.
@@ -51,51 +38,68 @@ type State struct {
 	// Merkle root of the results from executing prev block
 	LastResultsHash [32]byte
 
-	// LastStore height is the last height we've saved to the store.
-	LastStoreHeight uint64
-
-	// BaseHeight is the height of the first block we have in store after pruning.
-	BaseHeight uint64
-
 	// the latest AppHash we've received from calling abci.Commit()
 	AppHash [32]byte
 }
 
-// NewFromGenesisDoc reads blockchain State from genesis.
-func NewFromGenesisDoc(genDoc *types.GenesisDoc) (State, error) {
+// NewStateFromGenesis reads blockchain State from genesis.
+func NewStateFromGenesis(genDoc *types.GenesisDoc) (*State, error) {
 	err := genDoc.ValidateAndComplete()
 	if err != nil {
-		return State{}, fmt.Errorf("in genesis doc: %w", err)
+		return nil, fmt.Errorf("in genesis doc: %w", err)
 	}
 
-	var validatorSet, nextValidatorSet *types.ValidatorSet
-	validatorSet = types.NewValidatorSet(nil)
-	nextValidatorSet = types.NewValidatorSet(nil)
+	// InitStateVersion sets the Consensus.Block and Software versions,
+	// but leaves the Consensus.App version blank.
+	// The Consensus.App version will be set during the Handshake, once
+	// we hear from the app what protocol version it is running.
+	InitStateVersion := tmstate.Version{
+		Consensus: tmversion.Consensus{
+			Block: version.BlockProtocol,
+			App:   0,
+		},
+		Software: version.TMCoreSemVer,
+	}
 
 	s := State{
 		Version:       InitStateVersion,
 		ChainID:       genDoc.ChainID,
-		InitialHeight: genDoc.InitialHeight,
+		InitialHeight: uint64(genDoc.InitialHeight),
 
-		LastBlockHeight: 0,
-		LastBlockID:     types.BlockID{},
-		LastBlockTime:   genDoc.GenesisTime,
+		BaseHeight: uint64(genDoc.InitialHeight),
 
-		NextValidators:              nextValidatorSet,
-		Validators:                  validatorSet,
-		LastValidators:              types.NewValidatorSet(nil),
+		NextValidators:              types.NewValidatorSet(nil),
+		Validators:                  types.NewValidatorSet(nil),
 		LastHeightValidatorsChanged: genDoc.InitialHeight,
 
 		ConsensusParams:                  *genDoc.ConsensusParams,
 		LastHeightConsensusParamsChanged: genDoc.InitialHeight,
-
-		BaseHeight: 0,
 	}
+	s.LastBlockHeight.Store(0)
 	copy(s.AppHash[:], genDoc.AppHash)
 
-	return s, nil
+	return &s, nil
 }
 
 func (s *State) IsGenesis() bool {
-	return s.LastBlockHeight == 0
+	return s.Height() == 0
+}
+
+// SetHeight sets the height saved in the Store if it is higher than the existing height
+// returns OK if the value was updated successfully or did not need to be updated
+func (s *State) SetHeight(height uint64) {
+	s.LastBlockHeight.Store(height)
+}
+
+// Height returns height of the highest block saved in the Store.
+func (s *State) Height() uint64 {
+	return s.LastBlockHeight.Load()
+}
+
+// NextHeight returns the next height that expected to be stored in store.
+func (s *State) NextHeight() uint64 {
+	if s.IsGenesis() {
+		return s.InitialHeight
+	}
+	return s.Height() + 1
 }
diff --git a/types/validation.go b/types/validation.go
index f7f9f47b7..8e84f68e1 100644
--- a/types/validation.go
+++ b/types/validation.go
@@ -8,7 +8,7 @@ import (
 	tmtypes "github.com/tendermint/tendermint/types"
 )
 
-func ValidateProposedTransition(state State, block *Block, commit *Commit, proposer *Sequencer) error {
+func ValidateProposedTransition(state *State, block *Block, commit *Commit, proposer *Sequencer) error {
 	if err := block.ValidateWithState(state); err != nil {
 		return fmt.Errorf("block: %w", err)
 	}
@@ -39,7 +39,7 @@ func (b *Block) ValidateBasic() error {
 	return nil
 }
 
-func (b *Block) ValidateWithState(state State) error {
+func (b *Block) ValidateWithState(state *State) error {
 	err := b.ValidateBasic()
 	if err != nil {
 		return err
@@ -48,12 +48,11 @@ func (b *Block) ValidateWithState(state State) error {
 		b.Header.Version.Block != state.Version.Consensus.Block {
 		return errors.New("b version mismatch")
 	}
-	if state.LastBlockHeight <= 0 && b.Header.Height != uint64(state.InitialHeight) {
-		return errors.New("initial b height mismatch")
-	}
-	if state.LastBlockHeight > 0 && b.Header.Height != state.LastStoreHeight+1 {
-		return errors.New("b height mismatch")
+
+	if b.Header.Height != state.NextHeight() {
+		return errors.New("height mismatch")
 	}
+
 	if !bytes.Equal(b.Header.AppHash[:], state.AppHash[:]) {
 		return errors.New("AppHash mismatch")
 	}