blockchain: Optimize exported header access.

blockchain/blockindex_test.go

@@ -68,12 +68,12 @@ func TestBlockNodeHeader(t *testing.T) {
 	// Ensure fetching the header from the chain produces the same header used
 	// to create the node.
 	testHeaderHash := testHeader.BlockHash()
-	gotHeader, err := bc.FetchHeader(&testHeaderHash)
+	gotHeader, err := bc.HeaderByHash(&testHeaderHash)
 	if err != nil {
-		t.Fatalf("FetchHeader: unexpected error: %v", err)
+		t.Fatalf("HeaderByHash: unexpected error: %v", err)
 	}
 	if !reflect.DeepEqual(gotHeader, testHeader) {
-		t.Fatalf("FetchHeader: mismatched headers: got %+v, want %+v",
+		t.Fatalf("HeaderByHash: mismatched headers: got %+v, want %+v",
 			gotHeader, testHeader)
 	}
 }

blockchain/chain.go

@@ -1681,27 +1681,18 @@ func (b *BlockChain) MaxBlockSize() (int64, error) {
 	return maxSize, err
 }
 
-// FetchHeader returns the block header identified by the given hash or an error
-// if it doesn't exist.
+// HeaderByHash returns the block header identified by the given hash or an
+// error if it doesn't exist.  Note that this will return headers from both the
+// main chain and any side chains.
 //
 // This function is safe for concurrent access.
-func (b *BlockChain) FetchHeader(hash *chainhash.Hash) (wire.BlockHeader, error) {
-	// Reconstruct the header from the block index if possible.
-	if node := b.index.LookupNode(hash); node != nil {
-		return node.Header(), nil
+func (b *BlockChain) HeaderByHash(hash *chainhash.Hash) (wire.BlockHeader, error) {
+	node := b.index.LookupNode(hash)
+	if node == nil {
+		return wire.BlockHeader{}, fmt.Errorf("block %s is not known", hash)
 	}
 
-	// Fall back to loading it from the database.
-	var header *wire.BlockHeader
-	err := b.db.View(func(dbTx database.Tx) error {
-		var err error
-		header, err = dbFetchHeaderByHash(dbTx, hash)
-		return err
-	})
-	if err != nil {
-		return wire.BlockHeader{}, err
-	}
-	return *header, nil
+	return node.Header(), nil
 }
 
 // locateInventory returns the node of the block after the first known block in

rpcserver.go

@@ -2069,7 +2069,7 @@ func handleGetBlockHeader(s *rpcServer, cmd interface{}, closeChan <-chan struct
 	if err != nil {
 		return nil, rpcDecodeHexError(c.Hash)
 	}
-	blockHeader, err := s.chain.FetchHeader(hash)
+	blockHeader, err := s.chain.HeaderByHash(hash)
 	if err != nil {
 		return nil, &dcrjson.RPCError{
 			Code:    dcrjson.ErrRPCBlockNotFound,
@@ -3349,7 +3349,7 @@ func handleGetNetworkHashPS(s *rpcServer, cmd interface{}, closeChan <-chan stru
 		}
 
 		// Fetch the header from chain.
-		header, err := s.chain.FetchHeader(hash)
+		header, err := s.chain.HeaderByHash(hash)
 		if err != nil {
 			context := "Failed to fetch block header"
 			return nil, rpcInternalError(err.Error(), context)
@@ -3568,7 +3568,7 @@ func handleGetRawTransaction(s *rpcServer, cmd interface{}, closeChan <-chan str
 	)
 	if blkHash != nil {
 		// Fetch the header from chain.
-		header, err := s.chain.FetchHeader(blkHash)
+		header, err := s.chain.HeaderByHash(blkHash)
 		if err != nil {
 			context := "Failed to fetch block header"
 			return nil, rpcInternalError(err.Error(), context)
@@ -4960,7 +4960,7 @@ func handleSearchRawTransactions(s *rpcServer, cmd interface{}, closeChan <-chan
 		var blkHeight int64
 		if blkHash := rtx.blkHash; blkHash != nil {
 			// Fetch the header from chain.
-			header, err := s.chain.FetchHeader(blkHash)
+			header, err := s.chain.HeaderByHash(blkHash)
 			if err != nil {
 				return nil, &dcrjson.RPCError{
 					Code:    dcrjson.ErrRPCBlockNotFound,