Fusaka devnet 0

beacon/engine/types.go

@@ -123,6 +123,11 @@ type BlobAndProofV1 struct {
 	Proof hexutil.Bytes `json:"proof"`
 }
 
+type BlobAndProofV2 struct {
+	Blob       hexutil.Bytes   `json:"blob"`
+	CellProofs []hexutil.Bytes `json:"proofs"`
+}
+
 // JSON type overrides for ExecutionPayloadEnvelope.
 type executionPayloadEnvelopeMarshaling struct {
 	BlockValue *hexutil.Big
@@ -331,7 +336,9 @@ func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.
 		for j := range sidecar.Blobs {
 			bundle.Blobs = append(bundle.Blobs, hexutil.Bytes(sidecar.Blobs[j][:]))
 			bundle.Commitments = append(bundle.Commitments, hexutil.Bytes(sidecar.Commitments[j][:]))
-			bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(sidecar.Proofs[j][:]))
+		}
+		for _, proof := range sidecar.Proofs {
+			bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(proof[:]))
 		}
 	}
 

beacon/engine/types_test.go

@@ -0,0 +1,56 @@
+// Copyright 2025 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package engine
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+)
+
+func TestBlobs(t *testing.T) {
+	var (
+		emptyBlob          = new(kzg4844.Blob)
+		emptyBlobCommit, _ = kzg4844.BlobToCommitment(emptyBlob)
+		emptyBlobProof, _  = kzg4844.ComputeBlobProof(emptyBlob, emptyBlobCommit)
+		emptyCellProof, _  = kzg4844.ComputeCells(emptyBlob)
+	)
+	header := types.Header{}
+	block := types.NewBlock(&header, &types.Body{}, nil, nil)
+
+	sidecarWithoutCellProofs := &types.BlobTxSidecar{
+		Blobs:       []kzg4844.Blob{*emptyBlob},
+		Commitments: []kzg4844.Commitment{emptyBlobCommit},
+		Proofs:      []kzg4844.Proof{emptyBlobProof},
+	}
+	env := BlockToExecutableData(block, common.Big0, []*types.BlobTxSidecar{sidecarWithoutCellProofs}, nil)
+	if len(env.BlobsBundle.Proofs) != 1 {
+		t.Fatalf("Expect 1 proof in blobs bundle, got %v", len(env.BlobsBundle.Proofs))
+	}
+
+	sidecarWithCellProofs := &types.BlobTxSidecar{
+		Blobs:       []kzg4844.Blob{*emptyBlob},
+		Commitments: []kzg4844.Commitment{emptyBlobCommit},
+		Proofs:      emptyCellProof,
+	}
+	env = BlockToExecutableData(block, common.Big0, []*types.BlobTxSidecar{sidecarWithCellProofs}, nil)
+	if len(env.BlobsBundle.Proofs) != 128 {
+		t.Fatalf("Expect 128 proofs in blobs bundle, got %v", len(env.BlobsBundle.Proofs))
+	}
+}

consensus/misc/eip4844/eip4844.go

@@ -23,7 +23,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/params/forks"
 )
 
 var (
@@ -81,38 +80,49 @@ func CalcExcessBlobGas(config *params.ChainConfig, parent *types.Header, headTim
 
 // CalcBlobFee calculates the blobfee from the header's excess blob gas field.
 func CalcBlobFee(config *params.ChainConfig, header *types.Header) *big.Int {
-	var frac uint64
-	switch config.LatestFork(header.Time) {
-	case forks.Osaka:
-		frac = config.BlobScheduleConfig.Osaka.UpdateFraction
-	case forks.Prague:
-		frac = config.BlobScheduleConfig.Prague.UpdateFraction
-	case forks.Cancun:
-		frac = config.BlobScheduleConfig.Cancun.UpdateFraction
-	default:
+	blobConfig := latestBlobConfig(config, header.Time)
+	if blobConfig == nil {
 		panic("calculating blob fee on unsupported fork")
 	}
-	return fakeExponential(minBlobGasPrice, new(big.Int).SetUint64(*header.ExcessBlobGas), new(big.Int).SetUint64(frac))
+	return fakeExponential(minBlobGasPrice, new(big.Int).SetUint64(*header.ExcessBlobGas), new(big.Int).SetUint64(blobConfig.UpdateFraction))
 }
 
 // MaxBlobsPerBlock returns the max blobs per block for a block at the given timestamp.
 func MaxBlobsPerBlock(cfg *params.ChainConfig, time uint64) int {
-	if cfg.BlobScheduleConfig == nil {
+	blobConfig := latestBlobConfig(cfg, time)
+	if blobConfig == nil {
 		return 0
 	}
+	return blobConfig.Max
+}
+
+func latestBlobConfig(cfg *params.ChainConfig, time uint64) *params.BlobConfig {
+	if cfg.BlobScheduleConfig == nil {
+		return nil
+	}
 	var (
 		london = cfg.LondonBlock
 		s      = cfg.BlobScheduleConfig
 	)
 	switch {
+	case cfg.IsBPO5(london, time) && s.BPO5 != nil:
+		return s.BPO5
+	case cfg.IsBPO4(london, time) && s.BPO4 != nil:
+		return s.BPO4
+	case cfg.IsBPO3(london, time) && s.BPO3 != nil:
+		return s.BPO3
+	case cfg.IsBPO2(london, time) && s.BPO2 != nil:
+		return s.BPO2
+	case cfg.IsBPO1(london, time) && s.BPO1 != nil:
+		return s.BPO1
 	case cfg.IsOsaka(london, time) && s.Osaka != nil:
-		return s.Osaka.Max
+		return s.Osaka
 	case cfg.IsPrague(london, time) && s.Prague != nil:
-		return s.Prague.Max
+		return s.Prague
 	case cfg.IsCancun(london, time) && s.Cancun != nil:
-		return s.Cancun.Max
+		return s.Cancun
 	default:
-		return 0
+		return nil
 	}
 }
 
@@ -129,6 +139,16 @@ func LatestMaxBlobsPerBlock(cfg *params.ChainConfig) int {
 		return 0
 	}
 	switch {
+	case s.BPO5 != nil:
+		return s.BPO5.Max
+	case s.BPO4 != nil:
+		return s.BPO4.Max
+	case s.BPO3 != nil:
+		return s.BPO3.Max
+	case s.BPO2 != nil:
+		return s.BPO2.Max
+	case s.BPO1 != nil:
+		return s.BPO1.Max
 	case s.Osaka != nil:
 		return s.Osaka.Max
 	case s.Prague != nil:
@@ -142,23 +162,11 @@ func LatestMaxBlobsPerBlock(cfg *params.ChainConfig) int {
 
 // targetBlobsPerBlock returns the target number of blobs in a block at the given timestamp.
 func targetBlobsPerBlock(cfg *params.ChainConfig, time uint64) int {
-	if cfg.BlobScheduleConfig == nil {
-		return 0
-	}
-	var (
-		london = cfg.LondonBlock
-		s      = cfg.BlobScheduleConfig
-	)
-	switch {
-	case cfg.IsOsaka(london, time) && s.Osaka != nil:
-		return s.Osaka.Target
-	case cfg.IsPrague(london, time) && s.Prague != nil:
-		return s.Prague.Target
-	case cfg.IsCancun(london, time) && s.Cancun != nil:
-		return s.Cancun.Target
-	default:
+	blobConfig := latestBlobConfig(cfg, time)
+	if blobConfig == nil {
 		return 0
 	}
+	return blobConfig.Target
 }
 
 // fakeExponential approximates factor * e ** (numerator / denominator) using

core/txpool/blobpool/blobpool.go

@@ -36,7 +36,6 @@ 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"
@@ -1295,27 +1294,13 @@ func (p *BlobPool) GetMetadata(hash common.Hash) *txpool.TxMetadata {
 	}
 }
 
-// GetBlobs returns a number of blobs are proofs for the given versioned hashes.
+// 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) ([]*kzg4844.Blob, []*kzg4844.Proof) {
-	// Create a map of the blob hash to indices for faster fills
-	var (
-		blobs  = make([]*kzg4844.Blob, len(vhashes))
-		proofs = make([]*kzg4844.Proof, len(vhashes))
-	)
-	index := make(map[common.Hash]int)
-	for i, vhash := range vhashes {
-		index[vhash] = i
-	}
-	// Iterate over the blob hashes, pulling transactions that fill it. Take care
-	// to also fill anything else the transaction might include (probably will).
-	for i, vhash := range vhashes {
-		// If already filled by a previous fetch, skip
-		if blobs[i] != nil {
-			continue
-		}
-		// Unfilled, retrieve the datastore item (in a short lock)
+func (p *BlobPool) GetBlobs(vhashes []common.Hash) []*types.BlobTxSidecar {
+	sidecars := make([]*types.BlobTxSidecar, len(vhashes))
+	for idx, vhash := range vhashes {
+		// Retrieve the datastore item (in a short lock)
 		p.lock.RLock()
 		id, exists := p.lookup.storeidOfBlob(vhash)
 		if !exists {
@@ -1335,16 +1320,22 @@ func (p *BlobPool) GetBlobs(vhashes []common.Hash) ([]*kzg4844.Blob, []*kzg4844.
 			log.Error("Blobs corrupted for traced transaction", "id", id, "err", err)
 			continue
 		}
-		// Fill anything requested, not just the current versioned hash
-		sidecar := item.BlobTxSidecar()
-		for j, blobhash := range item.BlobHashes() {
-			if idx, ok := index[blobhash]; ok {
-				blobs[idx] = &sidecar.Blobs[j]
-				proofs[idx] = &sidecar.Proofs[j]
-			}
+		sidecars[idx] = item.BlobTxSidecar()
+	}
+	return sidecars
+}
+
+func (p *BlobPool) HasBlobs(vhashes []common.Hash) bool {
+	for _, vhash := range vhashes {
+		// Retrieve the datastore item (in a short lock)
+		p.lock.RLock()
+		_, exists := p.lookup.storeidOfBlob(vhash)
+		p.lock.RUnlock()
+		if !exists {
+			return false
 		}
 	}
-	return blobs, proofs
+	return true
 }
 
 // Add inserts a set of blob transactions into the pool if they pass validation (both

core/txpool/blobpool/blobpool_test.go

@@ -417,8 +417,23 @@ func verifyBlobRetrievals(t *testing.T, pool *BlobPool) {
 	for i := range testBlobVHashes {
 		copy(hashes[i][:], testBlobVHashes[i][:])
 	}
-	blobs, proofs := pool.GetBlobs(hashes)
-
+	sidecars := pool.GetBlobs(hashes)
+	var blobs []*kzg4844.Blob
+	var proofs []*kzg4844.Proof
+	for idx, sidecar := range sidecars {
+		if sidecar == nil {
+			blobs = append(blobs, nil)
+			proofs = append(proofs, nil)
+			continue
+		}
+		blobHashes := sidecar.BlobHashes()
+		for i, hash := range blobHashes {
+			if hash == hashes[idx] {
+				blobs = append(blobs, &sidecar.Blobs[i])
+				proofs = append(proofs, &sidecar.Proofs[i])
+			}
+		}
+	}
 	// Cross validate what we received vs what we wanted
 	if len(blobs) != len(hashes) || len(proofs) != len(hashes) {
 		t.Errorf("retrieved blobs/proofs size mismatch: have %d/%d, want %d", len(blobs), len(proofs), len(hashes))

core/txpool/legacypool/legacypool.go

@@ -35,7 +35,6 @@ 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"
@@ -1065,8 +1064,14 @@ func (pool *LegacyPool) GetMetadata(hash common.Hash) *txpool.TxMetadata {
 
 // GetBlobs is not supported by the legacy transaction pool, it is just here to
 // implement the txpool.SubPool interface.
-func (pool *LegacyPool) GetBlobs(vhashes []common.Hash) ([]*kzg4844.Blob, []*kzg4844.Proof) {
-	return nil, nil
+func (pool *LegacyPool) GetBlobs(vhashes []common.Hash) []*types.BlobTxSidecar {
+	return nil
+}
+
+// HasBlobs is not supported by the legacy transaction pool, it is just here to
+// implement the txpool.SubPool interface.
+func (pool *LegacyPool) HasBlobs(vhashes []common.Hash) bool {
+	return false
 }
 
 // Has returns an indicator whether txpool has a transaction cached with the

core/txpool/subpool.go

@@ -23,7 +23,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/holiman/uint256"
 )
@@ -136,7 +135,11 @@ type SubPool interface {
 	// GetBlobs returns a number of blobs are 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.
-	GetBlobs(vhashes []common.Hash) ([]*kzg4844.Blob, []*kzg4844.Proof)
+	GetBlobs(vhashes []common.Hash) []*types.BlobTxSidecar
+
+	// HasBlobs returns true if all blobs corresponding to the versioned hashes
+	// are in the sub pool.
+	HasBlobs(vhashes []common.Hash) bool
 
 	// ValidateTxBasics checks whether a transaction is valid according to the consensus
 	// rules, but does not check state-dependent validation such as sufficient balance.

core/txpool/txpool.go

@@ -26,7 +26,6 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"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/params"
@@ -311,17 +310,42 @@ func (p *TxPool) GetMetadata(hash common.Hash) *TxMetadata {
 // GetBlobs returns a number of blobs are 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 *TxPool) GetBlobs(vhashes []common.Hash) ([]*kzg4844.Blob, []*kzg4844.Proof) {
+func (p *TxPool) GetBlobs(vhashes []common.Hash) []*types.BlobTxSidecar {
 	for _, subpool := range p.subpools {
 		// It's an ugly to assume that only one pool will be capable of returning
-		// anything meaningful for this call, but anythingh else requires merging
+		// anything meaningful for this call, but anything else requires merging
 		// partial responses and that's too annoying to do until we get a second
 		// blobpool (probably never).
-		if blobs, proofs := subpool.GetBlobs(vhashes); blobs != nil {
-			return blobs, proofs
+		if sidecars := subpool.GetBlobs(vhashes); sidecars != nil {
+			return sidecars
 		}
 	}
-	return nil, nil
+	return nil
+}
+
+// HasBlobs will return true if all the vhashes are available in the same subpool.
+func (p *TxPool) HasBlobs(vhashes []common.Hash) bool {
+	for _, subpool := range p.subpools {
+		// It's an ugly to assume that only one pool will be capable of returning
+		// anything meaningful for this call, but anything else requires merging
+		// partial responses and that's too annoying to do until we get a second
+		// blobpool (probably never).
+		if subpool.HasBlobs(vhashes) {
+			return true
+		}
+	}
+	return false
+}
+
+// ValidateTxBasics checks whether a transaction is valid according to the consensus
+// rules, but does not check state-dependent validation such as sufficient balance.
+func (p *TxPool) ValidateTxBasics(tx *types.Transaction) error {
+	for _, subpool := range p.subpools {
+		if subpool.Filter(tx) {
+			return subpool.ValidateTxBasics(tx)
+		}
+	}
+	return fmt.Errorf("%w: received type %d", core.ErrTxTypeNotSupported, tx.Type())
 }
 
 // Add enqueues a batch of transactions into the pool if they are valid. Due