diff --git a/consensus/replay_test.go b/consensus/replay_test.go
index 76d36fce3..a081e262e 100644
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -1182,7 +1182,6 @@ func (bs *mockBlockStore) LoadBlock(height int64) *types.Block { return bs.chain
 func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
 	return bs.chain[int64(len(bs.chain))-1]
 }
-func (bs *mockBlockStore) LoadBlockMetaByHash(hash []byte) *types.BlockMeta { return nil }
 func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	block := bs.chain[height-1]
 	return &types.BlockMeta{
diff --git a/light/proxy/routes.go b/light/proxy/routes.go
index b3e12494e..2f53c8808 100644
--- a/light/proxy/routes.go
+++ b/light/proxy/routes.go
@@ -25,8 +25,6 @@ func RPCRoutes(c *lrpc.Client) map[string]*rpcserver.RPCFunc {
 		"genesis":              rpcserver.NewRPCFunc(makeGenesisFunc(c), ""),
 		"genesis_chunked":      rpcserver.NewRPCFunc(makeGenesisChunkedFunc(c), ""),
 		"block":                rpcserver.NewRPCFunc(makeBlockFunc(c), "height"),
-		"header":               rpcserver.NewRPCFunc(makeHeaderFunc(c), "height"),
-		"header_by_hash":       rpcserver.NewRPCFunc(makeHeaderByHashFunc(c), "hash"),
 		"block_by_hash":        rpcserver.NewRPCFunc(makeBlockByHashFunc(c), "hash"),
 		"block_results":        rpcserver.NewRPCFunc(makeBlockResultsFunc(c), "height"),
 		"commit":               rpcserver.NewRPCFunc(makeCommitFunc(c), "height"),
@@ -111,22 +109,6 @@ func makeBlockFunc(c *lrpc.Client) rpcBlockFunc {
 	}
 }
 
-type rpcHeaderFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultHeader, error)
-
-func makeHeaderFunc(c *lrpc.Client) rpcHeaderFunc {
-	return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultHeader, error) {
-		return c.Header(ctx.Context(), height)
-	}
-}
-
-type rpcHeaderByHashFunc func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultHeader, error)
-
-func makeHeaderByHashFunc(c *lrpc.Client) rpcHeaderByHashFunc {
-	return func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultHeader, error) {
-		return c.HeaderByHash(ctx.Context(), hash)
-	}
-}
-
 type rpcBlockByHashFunc func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error)
 
 func makeBlockByHashFunc(c *lrpc.Client) rpcBlockByHashFunc {
diff --git a/light/rpc/client.go b/light/rpc/client.go
index b3745b7f3..6fc1adbca 100644
--- a/light/rpc/client.go
+++ b/light/rpc/client.go
@@ -440,40 +440,6 @@ func (c *Client) BlockResults(ctx context.Context, height *int64) (*ctypes.Resul
 	return res, nil
 }
 
-// Header fetches and verifies the header directly via the light client
-func (c *Client) Header(ctx context.Context, height *int64) (*ctypes.ResultHeader, error) {
-	lb, err := c.updateLightClientIfNeededTo(ctx, height)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ctypes.ResultHeader{Header: lb.Header}, nil
-}
-
-// HeaderByHash calls rpcclient#HeaderByHash and updates the client if it's falling behind.
-func (c *Client) HeaderByHash(ctx context.Context, hash tmbytes.HexBytes) (*ctypes.ResultHeader, error) {
-	res, err := c.next.HeaderByHash(ctx, hash)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := res.Header.ValidateBasic(); err != nil {
-		return nil, err
-	}
-
-	lb, err := c.updateLightClientIfNeededTo(ctx, &res.Header.Height)
-	if err != nil {
-		return nil, err
-	}
-
-	if !bytes.Equal(lb.Header.Hash(), res.Header.Hash()) {
-		return nil, fmt.Errorf("primary header hash does not match trusted header hash. (%X != %X)",
-			lb.Header.Hash(), res.Header.Hash())
-	}
-
-	return res, nil
-}
-
 func (c *Client) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) {
 	// Update the light client if we're behind and retrieve the light block at the requested height
 	// or at the latest height if no height is provided.
diff --git a/rpc/client/http/http.go b/rpc/client/http/http.go
index 59f7c23ec..64c3cf727 100644
--- a/rpc/client/http/http.go
+++ b/rpc/client/http/http.go
@@ -98,11 +98,9 @@ type baseRPCClient struct {
 	caller jsonrpcclient.Caller
 }
 
-var (
-	_ rpcClient = (*HTTP)(nil)
-	_ rpcClient = (*BatchHTTP)(nil)
-	_ rpcClient = (*baseRPCClient)(nil)
-)
+var _ rpcClient = (*HTTP)(nil)
+var _ rpcClient = (*BatchHTTP)(nil)
+var _ rpcClient = (*baseRPCClient)(nil)
 
 //-----------------------------------------------------------------------------
 // HTTP
@@ -446,31 +444,6 @@ func (c *baseRPCClient) BlockResults(
 	return result, nil
 }
 
-func (c *baseRPCClient) Header(ctx context.Context, height *int64) (*ctypes.ResultHeader, error) {
-	result := new(ctypes.ResultHeader)
-	params := make(map[string]interface{})
-	if height != nil {
-		params["height"] = height
-	}
-	_, err := c.caller.Call(ctx, "header", params, result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (c *baseRPCClient) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultHeader, error) {
-	result := new(ctypes.ResultHeader)
-	params := map[string]interface{}{
-		"hash": hash,
-	}
-	_, err := c.caller.Call(ctx, "header_by_hash", params, result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
 func (c *baseRPCClient) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) {
 	result := new(ctypes.ResultCommit)
 	params := make(map[string]interface{})
diff --git a/rpc/client/interface.go b/rpc/client/interface.go
index 92783634c..36dc2f7d1 100644
--- a/rpc/client/interface.go
+++ b/rpc/client/interface.go
@@ -67,8 +67,6 @@ type SignClient interface {
 	Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error)
 	BlockByHash(ctx context.Context, hash []byte) (*ctypes.ResultBlock, error)
 	BlockResults(ctx context.Context, height *int64) (*ctypes.ResultBlockResults, error)
-	Header(ctx context.Context, height *int64) (*ctypes.ResultHeader, error)
-	HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultHeader, error)
 	Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error)
 	Validators(ctx context.Context, height *int64, page, perPage *int) (*ctypes.ResultValidators, error)
 	Tx(ctx context.Context, hash []byte, prove bool) (*ctypes.ResultTx, error)
diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go
index ca324dee0..d0dfc3723 100644
--- a/rpc/client/local/local.go
+++ b/rpc/client/local/local.go
@@ -169,14 +169,6 @@ func (c *Local) BlockResults(ctx context.Context, height *int64) (*ctypes.Result
 	return core.BlockResults(c.ctx, height)
 }
 
-func (c *Local) Header(ctx context.Context, height *int64) (*ctypes.ResultHeader, error) {
-	return core.Header(c.ctx, height)
-}
-
-func (c *Local) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultHeader, error) {
-	return core.HeaderByHash(c.ctx, hash)
-}
-
 func (c *Local) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) {
 	return core.Commit(c.ctx, height)
 }
diff --git a/rpc/client/mocks/client.go b/rpc/client/mocks/client.go
index 3569d54d6..f8eb7a45c 100644
--- a/rpc/client/mocks/client.go
+++ b/rpc/client/mocks/client.go
@@ -458,51 +458,6 @@ func (_m *Client) GenesisChunked(_a0 context.Context, _a1 uint) (*coretypes.Resu
 
 	return r0, r1
 }
-// Header provides a mock function with given fields: ctx, height
-func (_m *Client) Header(ctx context.Context, height *int64) (*coretypes.ResultHeader, error) {
-	ret := _m.Called(ctx, height)
-
-	var r0 *coretypes.ResultHeader
-	if rf, ok := ret.Get(0).(func(context.Context, *int64) *coretypes.ResultHeader); ok {
-		r0 = rf(ctx, height)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*coretypes.ResultHeader)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *int64) error); ok {
-		r1 = rf(ctx, height)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// HeaderByHash provides a mock function with given fields: ctx, hash
-func (_m *Client) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) {
-	ret := _m.Called(ctx, hash)
-
-	var r0 *coretypes.ResultHeader
-	if rf, ok := ret.Get(0).(func(context.Context, bytes.HexBytes) *coretypes.ResultHeader); ok {
-		r0 = rf(ctx, hash)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*coretypes.ResultHeader)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, bytes.HexBytes) error); ok {
-		r1 = rf(ctx, hash)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
 
 // Health provides a mock function with given fields: _a0
 func (_m *Client) Health(_a0 context.Context) (*coretypes.ResultHealth, error) {
diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go
index 72aa17a80..79102a364 100644
--- a/rpc/client/rpc_test.go
+++ b/rpc/client/rpc_test.go
@@ -285,15 +285,6 @@ func TestAppCalls(t *testing.T) {
 		require.NoError(err)
 		require.Equal(block, blockByHash)
 
-		// check that the header matches the block hash
-		header, err := c.Header(ctx, &apph)
-		require.NoError(err)
-		require.Equal(t, block.Block.Header, *header.Header)
-
-		headerByHash, err := c.HeaderByHash(ctx, block.BlockID.Hash)
-		require.NoError(err)
-		require.Equal(t, header, headerByHash)
-
 		// now check the results
 		blockResults, err := c.BlockResults(context.Background(), &txh)
 		require.Nil(err, "%d: %+v", i, err)
diff --git a/rpc/core/blocks.go b/rpc/core/blocks.go
index b63212eef..d42d0e9c9 100644
--- a/rpc/core/blocks.go
+++ b/rpc/core/blocks.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/tendermint/tendermint/libs/bytes"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
@@ -76,38 +75,6 @@ func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) {
 	return min, max, nil
 }
 
-// Header gets block header at a given height.
-// If no height is provided, it will fetch the latest header.
-// More: https://docs.tendermint.com/master/rpc/#/Info/header
-func Header(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultHeader, error) {
-	height, err := getHeight(env.BlockStore.Height(), heightPtr)
-	if err != nil {
-		return nil, err
-	}
-
-	blockMeta := env.BlockStore.LoadBlockMeta(height)
-	if blockMeta == nil {
-		return &ctypes.ResultHeader{}, nil
-	}
-
-	return &ctypes.ResultHeader{Header: &blockMeta.Header}, nil
-}
-
-// HeaderByHash gets header by hash.
-// More: https://docs.tendermint.com/master/rpc/#/Info/header_by_hash
-func HeaderByHash(ctx *rpctypes.Context, hash bytes.HexBytes) (*ctypes.ResultHeader, error) {
-	// N.B. The hash parameter is HexBytes so that the reflective parameter
-	// decoding logic in the HTTP service will correctly translate from JSON.
-	// See https://github.com/tendermint/tendermint/issues/6802 for context.
-
-	blockMeta := env.BlockStore.LoadBlockMetaByHash(hash)
-	if blockMeta == nil {
-		return &ctypes.ResultHeader{}, nil
-	}
-
-	return &ctypes.ResultHeader{Header: &blockMeta.Header}, nil
-}
-
 // Block gets block at a given height.
 // If no height is provided, it will fetch the latest block.
 // More: https://docs.tendermint.com/master/rpc/#/Info/block
diff --git a/rpc/core/blocks_test.go b/rpc/core/blocks_test.go
index be56ada50..161978d7b 100644
--- a/rpc/core/blocks_test.go
+++ b/rpc/core/blocks_test.go
@@ -14,7 +14,7 @@ import (
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	sm "github.com/tendermint/tendermint/state"
-	"github.com/tendermint/tendermint/state/mocks"
+	"github.com/tendermint/tendermint/types"
 )
 
 func TestBlockchainInfo(t *testing.T) {
@@ -84,10 +84,7 @@ func TestBlockResults(t *testing.T) {
 	env.StateStore = sm.NewStore(dbm.NewMemDB())
 	err := env.StateStore.SaveABCIResponses(100, results)
 	require.NoError(t, err)
-	mockstore := &mocks.BlockStore{}
-	mockstore.On("Height").Return(int64(100))
-	mockstore.On("Base").Return(int64(1))
-	env.BlockStore = mockstore
+	env.BlockStore = mockBlockStore{height: 100}
 
 	testCases := []struct {
 		height  int64
@@ -117,3 +114,21 @@ func TestBlockResults(t *testing.T) {
 		}
 	}
 }
+
+type mockBlockStore struct {
+	height int64
+}
+
+func (mockBlockStore) Base() int64                                       { return 1 }
+func (store mockBlockStore) Height() int64                               { return store.height }
+func (store mockBlockStore) Size() int64                                 { return store.height }
+func (mockBlockStore) LoadBaseMeta() *types.BlockMeta                    { return nil }
+func (mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta       { return nil }
+func (mockBlockStore) LoadBlock(height int64) *types.Block               { return nil }
+func (mockBlockStore) LoadBlockByHash(hash []byte) *types.Block          { return nil }
+func (mockBlockStore) LoadBlockPart(height int64, index int) *types.Part { return nil }
+func (mockBlockStore) LoadBlockCommit(height int64) *types.Commit        { return nil }
+func (mockBlockStore) LoadSeenCommit(height int64) *types.Commit         { return nil }
+func (mockBlockStore) PruneBlocks(height int64) (uint64, error)          { return 0, nil }
+func (mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+}
diff --git a/rpc/core/routes.go b/rpc/core/routes.go
index fe2d17e8b..195c6089a 100644
--- a/rpc/core/routes.go
+++ b/rpc/core/routes.go
@@ -24,8 +24,6 @@ var Routes = map[string]*rpc.RPCFunc{
 	"block_by_hash":        rpc.NewRPCFunc(BlockByHash, "hash"),
 	"block_results":        rpc.NewRPCFunc(BlockResults, "height"),
 	"commit":               rpc.NewRPCFunc(Commit, "height"),
-	"header":               rpc.NewRPCFunc(Header, "height"),
-	"header_by_hash":       rpc.NewRPCFunc(HeaderByHash, "hash"),
 	"check_tx":             rpc.NewRPCFunc(CheckTx, "tx"),
 	"tx":                   rpc.NewRPCFunc(Tx, "hash,prove"),
 	"tx_search":            rpc.NewRPCFunc(TxSearch, "query,prove,page,per_page,order_by"),
diff --git a/rpc/core/types/responses.go b/rpc/core/types/responses.go
index 3091d4534..68f3e2b96 100644
--- a/rpc/core/types/responses.go
+++ b/rpc/core/types/responses.go
@@ -39,11 +39,6 @@ type ResultBlock struct {
 	Block   *types.Block  `json:"block"`
 }
 
-// ResultHeader represents the response for a Header RPC Client query
-type ResultHeader struct {
-	Header *types.Header `json:"header"`
-}
-
 // Commit and Header
 type ResultCommit struct {
 	types.SignedHeader `json:"signed_header"`
diff --git a/rpc/openapi/openapi.yaml b/rpc/openapi/openapi.yaml
index 79c5144ef..ef06f9e63 100644
--- a/rpc/openapi/openapi.yaml
+++ b/rpc/openapi/openapi.yaml
@@ -500,7 +500,7 @@ paths:
                 $ref: "#/components/schemas/ErrorResponse"
   /net_info:
     get:
-      summary: Network information
+      summary: Network informations
       operationId: net_info
       tags:
         - Info
diff --git a/state/mocks/block_store.go b/state/mocks/block_store.go
index 278c52a1c..20e6a9b16 100644
--- a/state/mocks/block_store.go
+++ b/state/mocks/block_store.go
@@ -137,22 +137,6 @@ func (_m *BlockStore) LoadBlockPart(height int64, index int) *types.Part {
 	return r0
 }
 
-// LoadBlockMetaByHash provides a mock function with given fields: hash
-func (_m *BlockStore) LoadBlockMetaByHash(hash []byte) *types.BlockMeta {
-	ret := _m.Called(hash)
-
-	var r0 *types.BlockMeta
-	if rf, ok := ret.Get(0).(func([]byte) *types.BlockMeta); ok {
-		r0 = rf(hash)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.BlockMeta)
-		}
-	}
-
-	return r0
-}
-
 // LoadSeenCommit provides a mock function with given fields: height
 func (_m *BlockStore) LoadSeenCommit(height int64) *types.Commit {
 	ret := _m.Called(height)
diff --git a/state/services.go b/state/services.go
index 6e24af036..2b6c16fed 100644
--- a/state/services.go
+++ b/state/services.go
@@ -29,7 +29,6 @@ type BlockStore interface {
 	PruneBlocks(height int64) (uint64, error)
 
 	LoadBlockByHash(hash []byte) *types.Block
-	LoadBlockMetaByHash(hash []byte) *types.BlockMeta
 	LoadBlockPart(height int64, index int) *types.Part
 
 	LoadBlockCommit(height int64) *types.Commit
diff --git a/store/store.go b/store/store.go
index faf1e9ad8..6f27d27d1 100644
--- a/store/store.go
+++ b/store/store.go
@@ -196,26 +196,6 @@ func (bs *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	return blockMeta
 }
 
-// LoadBlockMetaByHash returns the blockmeta who's header corresponds to the given
-// hash. If none is found, returns nil.
-func (bs *BlockStore) LoadBlockMetaByHash(hash []byte) *types.BlockMeta {
-	bz, err := bs.db.Get(calcBlockHashKey(hash))
-	if err != nil {
-		panic(err)
-	}
-	if len(bz) == 0 {
-		return nil
-	}
-
-	s := string(bz)
-	height, err := strconv.ParseInt(s, 10, 64)
-
-	if err != nil {
-		panic(fmt.Sprintf("failed to extract height from %s: %v", s, err))
-	}
-	return bs.LoadBlockMeta(height)
-}
-
 // LoadBlockCommit returns the Commit for the given height.
 // This commit consists of the +2/3 and other Precommit-votes for block at `height`,
 // and it comes from the block.LastCommit for `height+1`.