core,core/rawdb, eth: return error when getting transfer logs

Author: tailingchen

core/blockchain.go

@@ -1430,9 +1430,11 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 		// Ensure genesis is in the ancient store
 		if blockChain[0].NumberU64() == 1 {
 			if frozen, _ := bc.db.Ancients(); frozen == 0 {
-				tfLogs := rawdb.ReadTransferLogs(bc.db, bc.genesisBlock.Hash(), frozen)
+				tfLogs, err := rawdb.ReadTransferLogs(bc.db, bc.genesisBlock.Hash(), frozen)
+				if err != nil {
+					return 0, err
+				}
 				writeSize, err := rawdb.WriteAncientBlocks(bc.db, []*types.Block{bc.genesisBlock}, []rlp.RawValue{rlp.EmptyList}, tfLogs)
-				size += writeSize
 				if err != nil {
 					log.Error("Error writing genesis to ancients", "err", err)
 					return 0, err

core/blockchain_reader.go

@@ -21,6 +21,8 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
@@ -524,10 +526,15 @@ func (bc *BlockChain) SubscribeBlockProcessingEvent(ch chan<- bool) event.Subscr
 }
 
 // GetTransferLogs retrieves the transfer logs for all transactions in a given block.
-func (bc *BlockChain) GetTransferLogs(hash common.Hash) []*types.TransferLog {
+func (bc *BlockChain) GetTransferLogs(hash common.Hash) ([]*types.TransferLog, error) {
 	number, ok := rawdb.ReadHeaderNumber(bc.db, hash)
 	if !ok {
-		return nil
+		return nil, ethereum.NotFound
+	}
+	transferLogs, err := rawdb.ReadTransferLogs(bc.db, hash, number)
+	if err != nil {
+		return nil, err
 	}
-	return rawdb.ReadTransferLogs(bc.db, hash, number)
+	bc.transferLogsCache.Add(hash, transferLogs)
+	return transferLogs, nil
 }

core/rawdb/accessors_chain.go

@@ -19,6 +19,7 @@ package rawdb
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math/big"
 	"slices"
@@ -33,6 +34,11 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
+var (
+	errNotFound            = errors.New("not found")
+	errMissingTransferLogs = errors.New("missing transfer logs")
+)
+
 // ReadCanonicalHash retrieves the hash assigned to a canonical block number.
 func ReadCanonicalHash(db ethdb.Reader, number uint64) common.Hash {
 	var data []byte
@@ -735,18 +741,21 @@ func ReadTransferLogsRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.R
 }
 
 // ReadTransferLogs retrieves all the transfer logs belonging to a block.
-func ReadTransferLogs(db ethdb.Reader, hash common.Hash, number uint64) []*types.TransferLog {
+func ReadTransferLogs(db ethdb.Reader, hash common.Hash, number uint64) ([]*types.TransferLog, error) {
 	// Retrieve the flattened transfer log slice
 	data := ReadTransferLogsRLP(db, hash, number)
 	if len(data) == 0 {
-		return nil
+		return nil, errNotFound
 	}
 	transferLogs := []*types.TransferLog{}
 	if err := rlp.DecodeBytes(data, &transferLogs); err != nil {
+		if string(data) == errMissingTransferLogs.Error() {
+			return nil, errMissingTransferLogs
+		}
 		log.Error("Invalid transfer log array RLP", "hash", hash, "number", number, "err", err)
-		return nil
+		return nil, err
 	}
-	return transferLogs
+	return transferLogs, nil
 }
 
 // WriteTransferLogs stores all the transfer logs belonging to a block.
@@ -763,7 +772,7 @@ func WriteTransferLogs(db ethdb.KeyValueWriter, hash common.Hash, number uint64,
 
 // WriteMissingTransferLogs stores missing transfer logs message for a block.
 func WriteMissingTransferLogs(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {
-	bytes := []byte("missing transfer logs")
+	bytes := []byte(errMissingTransferLogs.Error())
 	// Store the flattened transfer log slice
 	if err := db.Put(blockTransferLogsKey(number, hash), bytes); err != nil {
 		log.Crit("Failed to store block transfer logs", "hash", hash, "number", number, "err", err)
@@ -838,7 +847,7 @@ func writeAncientBlock(op ethdb.AncientWriteOp, block *types.Block, header *type
 			log.Crit("Failed to RLP encode block transfer logs", "err", err)
 		}
 	} else {
-		transferLogBlob = []byte("missing transfer logs")
+		transferLogBlob = []byte(errMissingTransferLogs.Error())
 	}
 	if err := op.AppendRaw(ChainFreezerTransferLogTable, num, transferLogBlob); err != nil {
 		return fmt.Errorf("can't append block %d transfer logs: %v", num, err)

core/rawdb/accessors_chain_test.go

@@ -502,8 +502,8 @@ func TestAncientTransferLogStorageTransferLog(t *testing.T) {
 	hash, number := block.Hash(), block.NumberU64()
 	// Write with nil transfer logs, should get nil transfer logs.
 	WriteAncientBlocks(db, []*types.Block{block}, types.EncodeBlockReceiptLists([]types.Receipts{nil}), nil)
-	if tlogs := ReadTransferLogs(db, hash, number); tlogs != nil {
-		t.Fatalf("should return nil transfer logs")
+	if tlogs, err := ReadTransferLogs(db, hash, number); tlogs != nil || err != errMissingTransferLogs {
+		t.Fatalf("should return nil transfer logs and missing transfer logs error")
 	}
 
 	// Create a test block
@@ -517,7 +517,7 @@ func TestAncientTransferLogStorageTransferLog(t *testing.T) {
 	hash, number = block2.Hash(), block2.NumberU64()
 	// Write with nil transfer logs, should get nil transfer logs.
 	WriteAncientBlocks(db, []*types.Block{block2}, types.EncodeBlockReceiptLists([]types.Receipts{nil}), []*types.TransferLog{})
-	if tlogs := ReadTransferLogs(db, hash, number); tlogs == nil {
+	if tlogs, err := ReadTransferLogs(db, hash, number); tlogs == nil || err != nil {
 		t.Fatalf("invalid transfer logs returned")
 	}
 }
@@ -1026,12 +1026,12 @@ func TestTransferLogStorage(t *testing.T) {
 
 	// Check that no transfer logs entries are in a pristine database
 	hash := common.BytesToHash([]byte{0x03, 0x14})
-	if ls := ReadTransferLogs(db, hash, 0); len(ls) != 0 {
+	if ls, err := ReadTransferLogs(db, hash, 0); len(ls) != 0 || err != errNotFound {
 		t.Fatalf("non existent transfer logs returned: %v", ls)
 	}
 	// Insert the transfer log slice into the database and check presence
 	WriteTransferLogs(db, hash, 0, transferLogs)
-	if ls := ReadTransferLogs(db, hash, 0); len(ls) == 0 {
+	if ls, err := ReadTransferLogs(db, hash, 0); len(ls) == 0 || err != nil {
 		t.Fatalf("no transfer logs returned")
 	} else {
 		for i := 0; i < len(transferLogs); i++ {
@@ -1045,7 +1045,13 @@ func TestTransferLogStorage(t *testing.T) {
 	}
 	// Delete the transfer log slice and check purge
 	DeleteTransferLogs(db, hash, 0)
-	if ls := ReadTransferLogs(db, hash, 0); len(ls) != 0 {
+	if ls, err := ReadTransferLogs(db, hash, 0); len(ls) != 0 || err != errNotFound {
 		t.Fatalf("deleted transfer logs returned: %v", ls)
 	}
+	// Insert missing transfer logs into the database and check error
+	hash2 := common.BytesToHash([]byte{0x07, 0x15})
+	WriteMissingTransferLogs(db, hash2, 1)
+	if ls, err := ReadTransferLogs(db, hash2, 1); len(ls) != 0 || err != errMissingTransferLogs {
+		t.Fatalf("no transfer logs returned and should return missing transfer logs error")
+	}
 }

eth/api_debug.go

@@ -535,10 +535,7 @@ func (api *DebugAPI) ExecutionWitnessByHash(hash common.Hash) (*stateless.ExtWit
 
 // GetTransferLogs is a debug API function that returns the transfer logs for a block hash, if known.
 func (api *DebugAPI) GetTransferLogs(ctx context.Context, hash common.Hash) ([]*types.TransferLog, error) {
-	if transferLogs := api.eth.blockchain.GetTransferLogs(hash); transferLogs != nil {
-		return transferLogs, nil
-	}
-	return nil, errors.New("unknown transfer logs")
+	return api.eth.blockchain.GetTransferLogs(hash)
 }
 
 // GetBlockReceipts returns all transaction receipts of the specified block.