capella upgrade

Author: avalonche

README.md

@@ -119,8 +119,11 @@ func NewSimulatedBackendChain(database ethdb.Database, blockchain *core.BlockCha
 	filterBackend := &filterBackend{database, blockchain, backend}
 	backend.filterSystem = filters.NewFilterSystem(filterBackend, filters.Config{})
 	backend.events = filters.NewEventSystem(backend.filterSystem, false)
-	backend.rollback(blockchain.CurrentBlock())
+	
+	header := backend.blockchain.CurrentBlock()
+	block := backend.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
 
+	backend.rollback(block)
 	return backend
 }
 

README.original.md

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -37,6 +38,8 @@ type PayloadAttributes struct {
 	Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
 	SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
 	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
+	GasLimit              uint64
+	Slot                  uint64
 }
 
 // JSON type overrides for PayloadAttributes.
@@ -237,3 +240,87 @@ type ExecutionPayloadBodyV1 struct {
 	TransactionData []hexutil.Bytes     `json:"transactions"`
 	Withdrawals     []*types.Withdrawal `json:"withdrawals"`
 }
+
+func ExecutionPayloadToBlock(payload *boostTypes.ExecutionPayload) (*types.Block, error) {
+	// TODO: separate decode function to avoid allocating twice
+	transactionBytes := make([][]byte, len(payload.Transactions))
+	for i, txHexBytes := range payload.Transactions {
+		transactionBytes[i] = txHexBytes[:]
+	}
+	txs, err := decodeTransactions(transactionBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	header := &types.Header{
+		ParentHash:  common.Hash(payload.ParentHash),
+		UncleHash:   types.EmptyUncleHash,
+		Coinbase:    common.Address(payload.FeeRecipient),
+		Root:        common.Hash(payload.StateRoot),
+		TxHash:      types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
+		ReceiptHash: common.Hash(payload.ReceiptsRoot),
+		Bloom:       types.BytesToBloom(payload.LogsBloom[:]),
+		Difficulty:  common.Big0,
+		Number:      new(big.Int).SetUint64(payload.BlockNumber),
+		GasLimit:    payload.GasLimit,
+		GasUsed:     payload.GasUsed,
+		Time:        payload.Timestamp,
+		BaseFee:     payload.BaseFeePerGas.BigInt(),
+		Extra:       payload.ExtraData,
+		MixDigest:   common.Hash(payload.Random),
+	}
+	block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */)
+	return block, nil
+}
+
+func ExecutionPayloadV2ToBlock(payload *capella.ExecutionPayload) (*types.Block, error) {
+	// TODO: separate decode function to avoid allocating twice
+	transactionBytes := make([][]byte, len(payload.Transactions))
+	for i, txHexBytes := range payload.Transactions {
+		transactionBytes[i] = txHexBytes[:]
+	}
+	txs, err := decodeTransactions(transactionBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	withdrawals := make([]*types.Withdrawal, len(payload.Withdrawals))
+	for i, withdrawal := range payload.Withdrawals {
+		withdrawals[i] = &types.Withdrawal{
+			Index:     uint64(withdrawal.Index),
+			Validator: uint64(withdrawal.ValidatorIndex),
+			Address:   common.Address(withdrawal.Address),
+			Amount:    uint64(withdrawal.Amount),
+		}
+	}
+	withdrawalsHash := types.DeriveSha(types.Withdrawals(withdrawals), trie.NewStackTrie(nil))
+
+	// base fee per gas is stored little-endian but we need it
+	// big-endian for big.Int.
+	var baseFeePerGasBytes [32]byte
+	for i := 0; i < 32; i++ {
+		baseFeePerGasBytes[i] = payload.BaseFeePerGas[32-1-i]
+	}
+	baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBytes[:])
+
+	header := &types.Header{
+		ParentHash:      common.Hash(payload.ParentHash),
+		UncleHash:       types.EmptyUncleHash,
+		Coinbase:        common.Address(payload.FeeRecipient),
+		Root:            common.Hash(payload.StateRoot),
+		TxHash:          types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
+		ReceiptHash:     common.Hash(payload.ReceiptsRoot),
+		Bloom:           types.BytesToBloom(payload.LogsBloom[:]),
+		Difficulty:      common.Big0,
+		Number:          new(big.Int).SetUint64(payload.BlockNumber),
+		GasLimit:        payload.GasLimit,
+		GasUsed:         payload.GasUsed,
+		Time:            payload.Timestamp,
+		BaseFee:         baseFeePerGas,
+		Extra:           payload.ExtraData,
+		MixDigest:       common.Hash(payload.PrevRandao),
+		WithdrawalsHash: &withdrawalsHash,
+	}
+	block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */).WithWithdrawals(withdrawals)
+	return block, nil
+}

accounts/abi/bind/backends/simulated.go

@@ -3,20 +3,28 @@ package builder
 import (
 	"context"
 	"errors"
+	"math/big"
 	_ "os"
 	"sync"
 	"time"
 
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	"github.com/attestantio/go-eth2-client/spec/capella"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/ethereum/go-ethereum/common"
 	blockvalidation "github.com/ethereum/go-ethereum/eth/block-validation"
+	"github.com/holiman/uint256"
 	"golang.org/x/time/rate"
 
+	"github.com/ethereum/go-ethereum/beacon/engine"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/beacon"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/flashbotsextra"
 	"github.com/ethereum/go-ethereum/log"
 
+	capellaapi "github.com/attestantio/go-builder-client/api/capella"
+	apiv1 "github.com/attestantio/go-builder-client/api/v1"
+
 	"github.com/flashbots/go-boost-utils/bls"
 	boostTypes "github.com/flashbots/go-boost-utils/types"
 )
@@ -38,6 +46,7 @@ type IBeaconClient interface {
 
 type IRelay interface {
 	SubmitBlock(msg *boostTypes.BuilderSubmitBlockRequest, vd ValidatorData) error
+	SubmitBlockCapella(msg *capellaapi.SubmitBlockRequest, vd ValidatorData) error
 	GetValidatorForSlot(nextSlot uint64) (ValidatorData, error)
 	Start() error
 	Stop()
@@ -99,16 +108,32 @@ func (b *Builder) Stop() error {
 	return nil
 }
 
-func (b *Builder) onSealedBlock(block *types.Block, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
-	executableData := beacon.BlockToExecutableData(block)
-	payload, err := executableDataToExecutionPayload(executableData)
+func (b *Builder) onSealedBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+	if b.eth.Config().IsShanghai(block.Time()) {
+		if err := b.submitCapellaBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
+			return err
+		}
+	} else {
+		if err := b.submitBellatrixBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, proposerPubkey, vd, attrs); err != nil {
+			return err
+		}
+	}
+
+	log.Info("submitted block", "slot", attrs.Slot, "value", blockValue.String(), "parent", block.ParentHash, "hash", block.Hash(), "#commitedBundles", len(commitedBundles))
+
+	return nil
+}
+
+func (b *Builder) submitBellatrixBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+	executableData := engine.BlockToExecutableData(block, blockValue)
+	payload, err := executableDataToExecutionPayload(executableData.ExecutionPayload)
 	if err != nil {
 		log.Error("could not format execution payload", "err", err)
 		return err
 	}
 
 	value := new(boostTypes.U256Str)
-	err = value.FromBig(block.Profit)
+	err = value.FromBig(blockValue)
 	if err != nil {
 		log.Error("could not set block value", "err", err)
 		return err
@@ -121,8 +146,8 @@ func (b *Builder) onSealedBlock(block *types.Block, ordersClosedAt time.Time, se
 		BuilderPubkey:        b.builderPublicKey,
 		ProposerPubkey:       proposerPubkey,
 		ProposerFeeRecipient: vd.FeeRecipient,
-		GasLimit:             executableData.GasLimit,
-		GasUsed:              executableData.GasUsed,
+		GasLimit:             executableData.ExecutionPayload.GasLimit,
+		GasUsed:              executableData.ExecutionPayload.GasUsed,
 		Value:                *value,
 	}
 
@@ -144,7 +169,7 @@ func (b *Builder) onSealedBlock(block *types.Block, ordersClosedAt time.Time, se
 			log.Error("could not validate block", "err", err)
 		}
 	} else {
-		go b.ds.ConsumeBuiltBlock(block, ordersClosedAt, sealedAt, commitedBundles, allBundles, &blockBidMsg)
+		go b.ds.ConsumeBuiltBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, &blockBidMsg)
 		err = b.relay.SubmitBlock(&blockSubmitReq, vd)
 		if err != nil {
 			log.Error("could not submit block", "err", err, "#commitedBundles", len(commitedBundles))
@@ -157,6 +182,56 @@ func (b *Builder) onSealedBlock(block *types.Block, ordersClosedAt time.Time, se
 	return nil
 }
 
+func (b *Builder) submitCapellaBlock(block *types.Block, blockValue *big.Int, ordersClosedAt time.Time, sealedAt time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle, proposerPubkey boostTypes.PublicKey, vd ValidatorData, attrs *types.BuilderPayloadAttributes) error {
+	executableData := engine.BlockToExecutableData(block, blockValue)
+	payload, err := executableDataToCapellaExecutionPayload(executableData.ExecutionPayload)
+	if err != nil {
+		log.Error("could not format execution payload", "err", err)
+		return err
+	}
+
+	value := new(boostTypes.U256Str)
+	err = value.FromBig(blockValue)
+	if err != nil {
+		log.Error("could not set block value", "err", err)
+		return err
+	}
+
+	blockBidMsg := apiv1.BidTrace{
+		Slot:                 attrs.Slot,
+		ParentHash:           payload.ParentHash,
+		BlockHash:            payload.BlockHash,
+		BuilderPubkey:        phase0.BLSPubKey(b.builderPublicKey),
+		ProposerPubkey:       phase0.BLSPubKey(proposerPubkey),
+		ProposerFeeRecipient: bellatrix.ExecutionAddress(vd.FeeRecipient),
+		GasLimit:             executableData.ExecutionPayload.GasLimit,
+		GasUsed:              executableData.ExecutionPayload.GasUsed,
+		Value:                uint256.NewInt(value.BigInt().Uint64()),
+	}
+
+	boostBidTrace := convertBidTrace(blockBidMsg)
+
+	signature, err := boostTypes.SignMessage(&blockBidMsg, b.builderSigningDomain, b.builderSecretKey)
+	if err != nil {
+		log.Error("could not sign builder bid", "err", err)
+		return err
+	}
+
+	blockSubmitReq := capellaapi.SubmitBlockRequest{
+		Signature:        phase0.BLSSignature(signature),
+		Message:          &blockBidMsg,
+		ExecutionPayload: payload,
+	}
+
+	go b.ds.ConsumeBuiltBlock(block, blockValue, ordersClosedAt, sealedAt, commitedBundles, allBundles, &boostBidTrace)
+	err = b.relay.SubmitBlockCapella(&blockSubmitReq, vd)
+	if err != nil {
+		log.Error("could not submit block", "err", err, "#commitedBundles", len(commitedBundles))
+		return err
+	}
+	return nil
+}
+
 func (b *Builder) OnPayloadAttribute(attrs *types.BuilderPayloadAttributes) error {
 	if attrs == nil {
 		return nil
@@ -203,7 +278,7 @@ func (b *Builder) OnPayloadAttribute(attrs *types.BuilderPayloadAttributes) erro
 	}
 
 	for _, currentAttrs := range b.slotAttrs {
-		if *attrs == currentAttrs {
+		if attrs.Equal(&currentAttrs) {
 			log.Debug("ignoring known payload attribute", "slot", attrs.Slot, "hash", attrs.HeadHash)
 			return nil
 		}
@@ -216,6 +291,7 @@ func (b *Builder) OnPayloadAttribute(attrs *types.BuilderPayloadAttributes) erro
 
 type blockQueueEntry struct {
 	block           *types.Block
+	blockValue      *big.Int
 	ordersCloseTime time.Time
 	sealedAt        time.Time
 	commitedBundles []types.SimulatedBundle
@@ -246,7 +322,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 	submitBestBlock := func() {
 		queueMu.Lock()
 		if queueBestEntry.block.Hash() != queueLastSubmittedHash {
-			err := b.onSealedBlock(queueBestEntry.block, queueBestEntry.ordersCloseTime, queueBestEntry.sealedAt, queueBestEntry.commitedBundles, queueBestEntry.allBundles, proposerPubkey, vd, attrs)
+			err := b.onSealedBlock(queueBestEntry.block, queueBestEntry.blockValue, queueBestEntry.ordersCloseTime, queueBestEntry.sealedAt, queueBestEntry.commitedBundles, queueBestEntry.allBundles, proposerPubkey, vd, attrs)
 
 			if err != nil {
 				log.Error("could not run sealed block hook", "err", err)
@@ -261,7 +337,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 	go runResubmitLoop(ctx, b.limiter, queueSignal, submitBestBlock)
 
 	// Populates queue with submissions that increase block profit
-	blockHook := func(block *types.Block, ordersCloseTime time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle) {
+	blockHook := func(block *types.Block, blockValue *big.Int, ordersCloseTime time.Time, commitedBundles []types.SimulatedBundle, allBundles []types.SimulatedBundle) {
 		if ctx.Err() != nil {
 			return
 		}
@@ -273,6 +349,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 		if block.Hash() != queueLastSubmittedHash {
 			queueBestEntry = blockQueueEntry{
 				block:           block,
+				blockValue:      new(big.Int).Set(blockValue),
 				ordersCloseTime: ordersCloseTime,
 				sealedAt:        sealedAt,
 				commitedBundles: commitedBundles,
@@ -296,7 +373,7 @@ func (b *Builder) runBuildingJob(slotCtx context.Context, proposerPubkey boostTy
 	})
 }
 
-func executableDataToExecutionPayload(data *beacon.ExecutableDataV1) (*boostTypes.ExecutionPayload, error) {
+func executableDataToExecutionPayload(data *engine.ExecutableData) (*boostTypes.ExecutionPayload, error) {
 	transactionData := make([]hexutil.Bytes, len(data.Transactions))
 	for i, tx := range data.Transactions {
 		transactionData[i] = hexutil.Bytes(tx)
@@ -325,3 +402,58 @@ func executableDataToExecutionPayload(data *beacon.ExecutableDataV1) (*boostType
 		Transactions:  transactionData,
 	}, nil
 }
+
+func executableDataToCapellaExecutionPayload(data *engine.ExecutableData) (*capella.ExecutionPayload, error) {
+	transactionData := make([]bellatrix.Transaction, len(data.Transactions))
+	for i, tx := range data.Transactions {
+		transactionData[i] = bellatrix.Transaction(tx)
+	}
+
+	withdrawalData := make([]*capella.Withdrawal, len(data.Withdrawals))
+	for i, wd := range data.Withdrawals {
+		withdrawalData[i] = &capella.Withdrawal{
+			Index:          capella.WithdrawalIndex(wd.Index),
+			ValidatorIndex: phase0.ValidatorIndex(wd.Validator),
+			Address:        bellatrix.ExecutionAddress(wd.Address),
+			Amount:         phase0.Gwei(wd.Amount),
+		}
+	}
+
+	baseFeePerGas := new(boostTypes.U256Str)
+	err := baseFeePerGas.FromBig(data.BaseFeePerGas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &capella.ExecutionPayload{
+		ParentHash:    [32]byte(data.ParentHash),
+		FeeRecipient:  [20]byte(data.FeeRecipient),
+		StateRoot:     [32]byte(data.StateRoot),
+		ReceiptsRoot:  [32]byte(data.ReceiptsRoot),
+		LogsBloom:     boostTypes.Bloom(types.BytesToBloom(data.LogsBloom)),
+		PrevRandao:    [32]byte(data.Random),
+		BlockNumber:   data.Number,
+		GasLimit:      data.GasLimit,
+		GasUsed:       data.GasUsed,
+		Timestamp:     data.Timestamp,
+		ExtraData:     data.ExtraData,
+		BaseFeePerGas: *baseFeePerGas,
+		BlockHash:     [32]byte(data.BlockHash),
+		Transactions:  transactionData,
+		Withdrawals:   withdrawalData,
+	}, nil
+}
+
+func convertBidTrace(bidTrace apiv1.BidTrace) boostTypes.BidTrace {
+	return boostTypes.BidTrace{
+		Slot:                 bidTrace.Slot,
+		ParentHash:           boostTypes.Hash(bidTrace.ParentHash),
+		BlockHash:            boostTypes.Hash(bidTrace.BlockHash),
+		BuilderPubkey:        boostTypes.PublicKey(bidTrace.BuilderPubkey),
+		ProposerPubkey:       boostTypes.PublicKey(bidTrace.ProposerPubkey),
+		ProposerFeeRecipient: boostTypes.Address(bidTrace.ProposerFeeRecipient),
+		GasLimit:             bidTrace.GasLimit,
+		GasUsed:              bidTrace.GasUsed,
+		Value:                boostTypes.IntToU256(bidTrace.Value.Uint64()),
+	}
+}