4844: All changes

.gitignore

@@ -52,3 +52,5 @@ cmd/geth/node/
 cmd/geth/__debug_bin
 cmd/bootnode/bootnode
 graphql/__debug_bin
+
+tempdatadir

accounts/abi/bind/backends/simulated.go

@@ -588,6 +588,7 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 
 // callContract implements common code between normal and pending contract calls.
 // state is modified during execution, make sure to copy it if necessary.
+// todo(4844?) header instead of block like geth?
 func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, stateDB *state.StateDB) (*core.ExecutionResult, error) {
 	// Gas prices post 1559 need to be initialized
 	if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
@@ -627,18 +628,26 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	if call.Value == nil {
 		call.Value = new(big.Int)
 	}
+
 	// Set infinite balance to the fake caller account.
 	from := stateDB.GetOrNewStateObject(call.From)
 	from.SetBalance(math.MaxBig256)
+	var excessDataGas *big.Int
+	// Get the last block header
+	ph := b.blockchain.GetHeaderByHash(block.ParentHash())
+	if ph != nil {
+		excessDataGas = ph.ExcessDataGas
+	}
 	// Execute the call.
 	msg := callMsg{call}
+	// todo check if SkipAccountChecks is really required
 
 	txContext := core.NewEVMTxContext(msg)
-	evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil)
+	evmContext := core.NewEVMBlockContext(block.Header(), excessDataGas, b.blockchain, nil)
 	// Create a new environment which holds all relevant information
 	// about the transaction and calling mechanisms.
 	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
-	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
+	gasPool := new(core.GasPool).AddGas(math.MaxUint64).AddDataGas(params.MaxDataGasPerBlock)
 
 	return core.NewStateTransition(vmEnv, msg, gasPool).TransitionDb()
 }
@@ -654,7 +663,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 		return fmt.Errorf("could not fetch parent")
 	}
 	// Check transaction validity
-	signer := types.MakeSigner(b.blockchain.Config(), block.Number())
+	signer := types.MakeSigner(b.blockchain.Config(), block.Number(), block.Time())
 	sender, err := types.Sender(signer, tx)
 	if err != nil {
 		return fmt.Errorf("invalid transaction: %v", err)
@@ -823,10 +832,12 @@ func (m callMsg) To() *common.Address          { return m.CallMsg.To }
 func (m callMsg) GasPrice() *big.Int           { return m.CallMsg.GasPrice }
 func (m callMsg) GasFeeCap() *big.Int          { return m.CallMsg.GasFeeCap }
 func (m callMsg) GasTipCap() *big.Int          { return m.CallMsg.GasTipCap }
+func (m callMsg) MaxFeePerDataGas() *big.Int   { return m.CallMsg.MaxFeePerDataGas }
 func (m callMsg) Gas() uint64                  { return m.CallMsg.Gas }
 func (m callMsg) Value() *big.Int              { return m.CallMsg.Value }
 func (m callMsg) Data() []byte                 { return m.CallMsg.Data }
 func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
+func (m callMsg) DataHashes() []common.Hash    { return m.CallMsg.DataHashes }
 
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.

accounts/external/backend.go

@@ -221,6 +221,18 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 	case types.DynamicFeeTxType:
 		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
 		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+	case types.BlobTxType:
+		hashes, _, blobs, proofs := tx.BlobWrapData()
+		if len(hashes) != len(blobs) {
+			return nil, fmt.Errorf("missing blobs data, expected %d blobs", len(hashes))
+		}
+		if len(hashes) != len(proofs) {
+			return nil, fmt.Errorf("missing proofs data, expected %d proofs", len(proofs))
+		}
+
+		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
+		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+		args.Blobs = blobs
 	default:
 		return nil, fmt.Errorf("unsupported tx type %d", tx.Type())
 	}

beacon/engine/types.go

@@ -16,3 +16,81 @@
 
 // just for prysm compile pass
 package engine
+
+import (
+	"fmt"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// BlobsBundle holds the blobs of an execution payload
+type BlobsBundle struct {
+	Commitments []types.KZGCommitment `json:"commitments" gencodec:"required"`
+	Blobs       []types.Blob          `json:"blobs"       gencodec:"required"`
+	Proofs      []types.KZGProof      `json:"proofs"      gencodec:"required"`
+}
+
+func BlockToBlobData(block *types.Block) (*BlobsBundle, error) {
+	blobsBundle := &BlobsBundle{
+		Blobs:       []types.Blob{},
+		Commitments: []types.KZGCommitment{},
+		Proofs:      []types.KZGProof{},
+	}
+	for i, tx := range block.Transactions() {
+		if tx.Type() == types.BlobTxType {
+			versionedHashes, commitments, blobs, proofs := tx.BlobWrapData()
+			if len(versionedHashes) != len(commitments) || len(versionedHashes) != len(blobs) || len(blobs) != len(proofs) {
+				return nil, fmt.Errorf("tx %d in block %s has inconsistent blobs (%d) / commitments (%d)"+
+					" / versioned hashes (%d) / proofs (%d)", i, block.Hash(), len(blobs), len(commitments), len(versionedHashes), len(proofs))
+			}
+
+			blobsBundle.Blobs = append(blobsBundle.Blobs, blobs...)
+			blobsBundle.Commitments = append(blobsBundle.Commitments, commitments...)
+			blobsBundle.Proofs = append(blobsBundle.Proofs, proofs...)
+		}
+	}
+	return blobsBundle, nil
+}
+
+func BlockToSidecars(block *types.Block) ([]*types.Sidecar, error) {
+	//blobsBundle := &BlobsBundle{
+	//	Blobs:       []types.Blob{},
+	//	Commitments: []types.KZGCommitment{},
+	//	Proofs:      []types.KZGProof{},
+	//}
+
+	sidecars := make([]*types.Sidecar, 0)
+
+	for i, tx := range block.Transactions() {
+		if tx.Type() == types.BlobTxType {
+			log.Info("Blob Tx detected...........!!!!!!!!!!!")
+			versionedHashes, commitments, blobs, proofs := tx.BlobWrapData()
+			if len(versionedHashes) != len(commitments) || len(versionedHashes) != len(blobs) || len(blobs) != len(proofs) {
+				return nil, fmt.Errorf("tx %d in block %s has inconsistent blobs (%d) / commitments (%d)"+
+					" / versioned hashes (%d) / proofs (%d)", i, block.Hash(), len(blobs), len(commitments), len(versionedHashes), len(proofs))
+			}
+			blockRoot := block.Root()
+			blockParentRoot := block.ParentHash()
+			for index, blob := range blobs {
+				sidecar := &types.Sidecar{
+					BlockRoot:       blockRoot,
+					BlockParentRoot: blockParentRoot,
+					Index:           block.NumberU64(),
+					Blob:            blob,
+					KZGCommitment:   commitments[index],
+					KZGProof:        proofs[index],
+				}
+				sidecars = append(sidecars, sidecar)
+			}
+			log.Info("Sidecars: ", sidecars[0])
+
+			//blobsBundle.Blobs = append(blobsBundle.Blobs, blobs...)
+			//blobsBundle.Commitments = append(blobsBundle.Commitments, commitments...)
+			//blobsBundle.Proofs = append(blobsBundle.Proofs, proofs...)
+		}
+	}
+
+	return sidecars, nil
+}
+
+//func TransactionsToSidecars(txs []*types.Transaction, )

cmd/evm/internal/t8ntool/block.go

@@ -187,12 +187,12 @@ func (i *bbInput) sealEthash(block *types.Block) (*types.Block, error) {
 	// Use a buffered chan for results.
 	// If the testmode is used, the sealer will return quickly, and complain
 	// "Sealing result is not read by miner" if it cannot write the result.
-	results := make(chan *types.Block, 1)
-	if err := engine.Seal(nil, block, results, nil); err != nil {
+	results := make(chan *types.BlockAndSidecars, 1)
+	if err := engine.Seal(nil, &types.BlockAndSidecars{Block: block}, results, nil); err != nil {
 		panic(fmt.Sprintf("failed to seal block: %v", err))
 	}
 	found := <-results
-	return block.WithSeal(found.Header()), nil
+	return block.WithSeal(found.Block.Header()), nil
 }
 
 // sealClique seals the given block using clique.

cmd/evm/internal/t8ntool/execution.go

@@ -47,15 +47,16 @@ type Prestate struct {
 // ExecutionResult contains the execution status after running a state test, any
 // error that might have occurred and a dump of the final state if requested.
 type ExecutionResult struct {
-	StateRoot   common.Hash           `json:"stateRoot"`
-	TxRoot      common.Hash           `json:"txRoot"`
-	ReceiptRoot common.Hash           `json:"receiptsRoot"`
-	LogsHash    common.Hash           `json:"logsHash"`
-	Bloom       types.Bloom           `json:"logsBloom"        gencodec:"required"`
-	Receipts    types.Receipts        `json:"receipts"`
-	Rejected    []*rejectedTx         `json:"rejected,omitempty"`
-	Difficulty  *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
-	GasUsed     math.HexOrDecimal64   `json:"gasUsed"`
+	StateRoot     common.Hash           `json:"stateRoot"`
+	TxRoot        common.Hash           `json:"txRoot"`
+	ReceiptRoot   common.Hash           `json:"receiptsRoot"`
+	LogsHash      common.Hash           `json:"logsHash"`
+	Bloom         types.Bloom           `json:"logsBloom"        gencodec:"required"`
+	Receipts      types.Receipts        `json:"receipts"`
+	Rejected      []*rejectedTx         `json:"rejected,omitempty"`
+	Difficulty    *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
+	GasUsed       math.HexOrDecimal64   `json:"gasUsed"`
+	ExcessDataGas *math.HexOrDecimal256 `json:"currentExcessDataGas,omitempty"`
 }
 
 type ommer struct {
@@ -65,30 +66,38 @@ type ommer struct {
 
 //go:generate gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
 type stEnv struct {
-	Coinbase         common.Address                      `json:"currentCoinbase"   gencodec:"required"`
-	Difficulty       *big.Int                            `json:"currentDifficulty"`
-	Random           *big.Int                            `json:"currentRandom"`
-	ParentDifficulty *big.Int                            `json:"parentDifficulty"`
-	GasLimit         uint64                              `json:"currentGasLimit"   gencodec:"required"`
-	Number           uint64                              `json:"currentNumber"     gencodec:"required"`
-	Timestamp        uint64                              `json:"currentTimestamp"  gencodec:"required"`
-	ParentTimestamp  uint64                              `json:"parentTimestamp,omitempty"`
-	BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-	Ommers           []ommer                             `json:"ommers,omitempty"`
-	BaseFee          *big.Int                            `json:"currentBaseFee,omitempty"`
-	ParentUncleHash  common.Hash                         `json:"parentUncleHash"`
+	Coinbase            common.Address                      `json:"currentCoinbase"   gencodec:"required"`
+	Difficulty          *big.Int                            `json:"currentDifficulty"`
+	Random              *big.Int                            `json:"currentRandom"`
+	ParentDifficulty    *big.Int                            `json:"parentDifficulty"`
+	ParentBaseFee       *big.Int                            `json:"parentBaseFee,omitempty"`
+	ParentGasUsed       uint64                              `json:"parentGasUsed,omitempty"`
+	ParentGasLimit      uint64                              `json:"parentGasLimit,omitempty"`
+	ParentExcessDataGas *big.Int                            `json:"parentExcessDataGas,omitempty"`
+	GasLimit            uint64                              `json:"currentGasLimit"   gencodec:"required"`
+	Number              uint64                              `json:"currentNumber"     gencodec:"required"`
+	Timestamp           uint64                              `json:"currentTimestamp"  gencodec:"required"`
+	ParentTimestamp     uint64                              `json:"parentTimestamp,omitempty"`
+	BlockHashes         map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
+	Ommers              []ommer                             `json:"ommers,omitempty"`
+	BaseFee             *big.Int                            `json:"currentBaseFee,omitempty"`
+	ParentUncleHash     common.Hash                         `json:"parentUncleHash"`
 }
 
 type stEnvMarshaling struct {
-	Coinbase         common.UnprefixedAddress
-	Difficulty       *math.HexOrDecimal256
-	Random           *math.HexOrDecimal256
-	ParentDifficulty *math.HexOrDecimal256
-	GasLimit         math.HexOrDecimal64
-	Number           math.HexOrDecimal64
-	Timestamp        math.HexOrDecimal64
-	ParentTimestamp  math.HexOrDecimal64
-	BaseFee          *math.HexOrDecimal256
+	Coinbase            common.UnprefixedAddress
+	Difficulty          *math.HexOrDecimal256
+	Random              *math.HexOrDecimal256
+	ParentDifficulty    *math.HexOrDecimal256
+	ParentBaseFee       *math.HexOrDecimal256
+	ParentGasUsed       math.HexOrDecimal64
+	ParentGasLimit      math.HexOrDecimal64
+	ParentExcessDataGas *math.HexOrDecimal256
+	GasLimit            math.HexOrDecimal64
+	Number              math.HexOrDecimal64
+	Timestamp           math.HexOrDecimal64
+	ParentTimestamp     math.HexOrDecimal64
+	BaseFee             *math.HexOrDecimal256
 }
 
 type rejectedTx struct {
@@ -117,7 +126,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	}
 	var (
 		statedb     = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre)
-		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number))
+		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
 		gaspool     = new(core.GasPool)
 		blockHash   = common.Hash{0x13, 0x37}
 		rejectedTxs []*rejectedTx
@@ -126,7 +135,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		receipts    = make(types.Receipts, 0)
 		txIndex     = 0
 	)
+	// TODO(4844): Add DataGasLimit to prestate
 	gaspool.AddGas(pre.Env.GasLimit)
+	gaspool.AddDataGas(params.MaxDataGasPerBlock)
 	vmContext := vm.BlockContext{
 		CanTransfer: core.CanTransfer,
 		Transfer:    core.Transfer,
@@ -146,6 +157,13 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		rnd := common.BigToHash(pre.Env.Random)
 		vmContext.Random = &rnd
 	}
+	if chainConfig.IsCancun(pre.Env.Timestamp) {
+		if pre.Env.ParentExcessDataGas != nil {
+			vmContext.ExcessDataGas = pre.Env.ParentExcessDataGas
+		} else {
+			vmContext.ExcessDataGas = big.NewInt(0)
+		}
+	}
 	// If DAO is supported/enabled, we need to handle it here. In geth 'proper', it's
 	// done in StateProcessor.Process(block, ...), right before transactions are applied.
 	if chainConfig.DAOForkSupport &&
@@ -156,6 +174,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 
 	for i, tx := range txs {
 		msg, err := tx.AsMessage(signer, pre.Env.BaseFee)
+		if tx.Type() == types.BlobTxType && len(tx.DataHashes()) == 0 {
+			err = fmt.Errorf("blob transaction with zero blobs")
+		}
 		if err != nil {
 			log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
@@ -168,8 +189,12 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		vmConfig.Tracer = tracer
 		vmConfig.Debug = (tracer != nil)
 		statedb.Prepare(tx.Hash(), txIndex)
-		txContext := core.NewEVMTxContext(msg)
-		snapshot := statedb.Snapshot()
+		var (
+			txContext   = core.NewEVMTxContext(msg)
+			snapshot    = statedb.Snapshot()
+			prevGas     = gaspool.Gas()
+			prevDataGas = gaspool.DataGas()
+		)
 		evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
 
 		// (ret []byte, usedGas uint64, failed bool, err error)
@@ -178,6 +203,8 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			statedb.RevertToSnapshot(snapshot)
 			log.Info("rejected tx", "index", i, "hash", tx.Hash(), "from", msg.From(), "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})
+			gaspool.SetGas(prevGas)
+			gaspool.SetDataGas(prevDataGas)
 			continue
 		}
 		includedTxs = append(includedTxs, tx)
@@ -267,6 +294,16 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		Difficulty:  (*math.HexOrDecimal256)(vmContext.Difficulty),
 		GasUsed:     (math.HexOrDecimal64)(gasUsed),
 	}
+	if vmContext.ExcessDataGas != nil {
+		// calculate and set the excess data gas at the end of this block execution
+		newBlobs := 0
+		for _, tx := range txs {
+			if tx.Type() == types.BlobTxType {
+				newBlobs += len(tx.DataHashes())
+			}
+		}
+		execRs.ExcessDataGas = (*math.HexOrDecimal256)(misc.CalcExcessDataGas(vmContext.ExcessDataGas, newBlobs))
+	}
 	return statedb, execRs, nil
 }
 

cmd/evm/internal/t8ntool/transaction.go

@@ -112,7 +112,7 @@ func Transaction(ctx *cli.Context) error {
 			return NewError(ErrorIO, errors.New("only rlp supported"))
 		}
 	}
-	signer := types.MakeSigner(chainConfig, new(big.Int))
+	signer := types.MakeSigner(chainConfig, new(big.Int), 0)
 	// We now have the transactions in 'body', which is supposed to be an
 	// rlp list of transactions
 	it, err := rlp.NewListIterator([]byte(body))

cmd/evm/internal/t8ntool/transition.go

@@ -242,7 +242,7 @@ func Transition(ctx *cli.Context) error {
 		}
 	}
 	// We may have to sign the transactions.
-	signer := types.MakeSigner(chainConfig, big.NewInt(int64(prestate.Env.Number)))
+	signer := types.LatestSignerForChainID(chainConfig.ChainID)
 
 	if txs, err = signUnsignedTransactions(txsWithKeys, signer); err != nil {
 		return NewError(ErrorJson, fmt.Errorf("failed signing transactions: %v", err))