core/txpool/blobpool: improve GetBlobs

Author: rjl493456442

core/txpool/blobpool/blobpool.go

@@ -25,7 +25,6 @@ import (
 	"math/big"
 	"os"
 	"path/filepath"
-	"slices"
 	"sort"
 	"sync"
 	"time"
@@ -37,6 +36,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/txpool"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
@@ -1300,46 +1300,86 @@ func (p *BlobPool) GetMetadata(hash common.Hash) *txpool.TxMetadata {
 // GetBlobs returns a number of blobs and proofs for the given versioned hashes.
 // This is a utility method for the engine API, enabling consensus clients to
 // retrieve blobs from the pools directly instead of the network.
-func (p *BlobPool) GetBlobs(vhashes []common.Hash) []*types.BlobTxSidecar {
-	sidecars := make([]*types.BlobTxSidecar, len(vhashes))
-	for idx, vhash := range vhashes {
-		if sidecars[idx] != nil {
+func (p *BlobPool) GetBlobs(vhashes []common.Hash, version byte) ([]*kzg4844.Blob, []kzg4844.Commitment, [][]kzg4844.Proof, error) {
+	var (
+		blobs       = make([]*kzg4844.Blob, len(vhashes))
+		commitments = make([]kzg4844.Commitment, len(vhashes))
+		proofs      = make([][]kzg4844.Proof, len(vhashes))
+
+		indices = make(map[common.Hash][]int)
+		filled  = make(map[common.Hash]struct{})
+	)
+	for i, h := range vhashes {
+		indices[h] = append(indices[h], i)
+	}
+	for _, vhash := range vhashes {
+		// Skip duplicate vhash that was already resolved in a previous iteration
+		if _, ok := filled[vhash]; ok {
 			continue
 		}
-		// Retrieve the datastore item (in a short lock)
+		// Retrieve the corresponding blob tx with the vhash
 		p.lock.RLock()
-		id, exists := p.lookup.storeidOfBlob(vhash)
+		txID, exists := p.lookup.storeidOfBlob(vhash)
+		p.lock.RUnlock()
 		if !exists {
-			p.lock.RUnlock()
-			continue
+			return nil, nil, nil, fmt.Errorf("blob with vhash %x is not found", vhash)
 		}
-		data, err := p.store.Get(id)
-		p.lock.RUnlock()
-
-		// After releasing the lock, try to fill any blobs requested
+		data, err := p.store.Get(txID)
 		if err != nil {
-			log.Error("Tracked blob transaction missing from store", "id", id, "err", err)
-			continue
+			return nil, nil, nil, err
 		}
-		item := new(types.Transaction)
-		if err = rlp.DecodeBytes(data, item); err != nil {
-			log.Error("Blobs corrupted for traced transaction", "id", id, "err", err)
-			continue
-		}
-		sidecars[idx] = item.BlobTxSidecar()
 
-		// If multi blobs in the same transaction, fill the other sidecars.
-		hashes := item.BlobHashes()
-		for i, vHash := range vhashes {
-			if sidecars[i] != nil {
-				continue
+		// Decode the blob transaction
+		tx := new(types.Transaction)
+		if err := rlp.DecodeBytes(data, tx); err != nil {
+			return nil, nil, nil, err
+		}
+		sidecar := tx.BlobTxSidecar()
+		if sidecar == nil {
+			return nil, nil, nil, fmt.Errorf("blob tx without sidecar %x", tx.Hash())
+		}
+		// Traverse the blobs in the transaction
+		for i, hash := range tx.BlobHashes() {
+			list, ok := indices[hash]
+			if !ok {
+				continue // non-interesting blob
+			}
+			var pf []kzg4844.Proof
+			switch version {
+			case types.BlobSidecarVersion0:
+				if sidecar.Version == types.BlobSidecarVersion0 {
+					pf = []kzg4844.Proof{sidecar.Proofs[i]}
+				} else {
+					proof, err := kzg4844.ComputeBlobProof(&sidecar.Blobs[i], sidecar.Commitments[i])
+					if err != nil {
+						return nil, nil, nil, err
+					}
+					pf = []kzg4844.Proof{proof}
+				}
+			case types.BlobSidecarVersion1:
+				if sidecar.Version == types.BlobSidecarVersion0 {
+					cellProofs, err := kzg4844.ComputeCellProofs(&sidecar.Blobs[i])
+					if err != nil {
+						return nil, nil, nil, err
+					}
+					pf = cellProofs
+				} else {
+					cellProofs, err := sidecar.CellProofsAt(i)
+					if err != nil {
+						return nil, nil, nil, err
+					}
+					pf = cellProofs
+				}
 			}
-			if slices.Index(hashes, vHash) != -1 {
-				sidecars[i] = item.BlobTxSidecar()
+			for _, index := range list {
+				blobs[index] = &sidecar.Blobs[i]
+				commitments[index] = sidecar.Commitments[i]
+				proofs[index] = pf
 			}
+			filled[hash] = struct{}{}
 		}
 	}
-	return sidecars
+	return blobs, commitments, proofs, nil
 }
 
 // AvailableBlobs returns the number of blobs that are available in the subpool.