Datablob transactions

accounts/abi/bind/backends/simulated.go

@@ -812,6 +812,7 @@ 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,10 @@ 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:
+		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
+		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+		args.BlobVersionedHashes = tx.BlobVersionedHashes()
 	default:
 		return nil, fmt.Errorf("unsupported tx type %d", tx.Type())
 	}

cmd/evm/internal/t8ntool/transaction.go

@@ -139,7 +139,7 @@ func Transaction(ctx *cli.Context) error {
 			r.Address = sender
 		}
 		// Check intrinsic gas
-		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,
+		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), len(tx.BlobVersionedHashes()), tx.To() == nil,
 			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int))); err != nil {
 			r.Error = err
 			results = append(results, r)

cmd/kzg_dummy_setup/main.go

@@ -0,0 +1,52 @@
+// **NEVER EVER** use the output of this script in production
+//
+// Do a dummy KZG trusted setup ceremony for testing purposes
+// Dump a json file with the results
+//
+// **NEVER EVER** use the output of this script in production
+
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"math"
+
+	gokzg "github.com/protolambda/go-kzg"
+	"github.com/protolambda/go-kzg/bls"
+)
+
+const CHUNKS_PER_BLOB = 4096
+
+type JSONTrustedSetup struct {
+	SetupG1       []bls.G1Point
+	SetupG2       []bls.G2Point
+	SetupLagrange []bls.G1Point
+}
+
+func main() {
+	// Generate roots of unity
+	fs := gokzg.NewFFTSettings(uint8(math.Log2(CHUNKS_PER_BLOB)))
+
+	// Create a CRS for `s` with CHUNKS_PER_BLOB elements
+	s := "1927409816240961209460912649124"
+	kzg_setup_g1, kzg_setup_g2 := gokzg.GenerateTestingSetup(s, CHUNKS_PER_BLOB)
+
+	// Also create the lagrange CRS
+	kzg_setup_lagrange, err := fs.FFTG1(kzg_setup_g1[:CHUNKS_PER_BLOB], true)
+	if err != nil {
+		panic(err)
+	}
+
+	var trusted_setup = JSONTrustedSetup{}
+	trusted_setup.SetupG1 = kzg_setup_g1
+	trusted_setup.SetupG2 = kzg_setup_g2
+	trusted_setup.SetupLagrange = kzg_setup_lagrange
+
+	json_trusted_setup, _ := json.Marshal(trusted_setup)
+
+	err = ioutil.WriteFile("kzg_trusted_setup.json", json_trusted_setup, 0644)
+	if err != nil {
+		panic(err)
+	}
+}

core/beacon/types.go

@@ -40,6 +40,17 @@ type payloadAttributesMarshaling struct {
 	Timestamp hexutil.Uint64
 }
 
+type BlobDetailsV1 struct {
+	KZG  types.KZGCommitment `json:"kzg"`
+	Blob types.Blob          `json:"blob"`
+}
+
+// ExecutionWrapperV1 is data around the execution payload, to be retrieved separately
+type ExecutionWrapperV1 struct {
+	// Blob details by versioned hash. Values may be nil if the wrapping blob data was removed/unavailable.
+	Blobs map[common.Hash]*BlobDetailsV1 `json:"blobs"`
+}
+
 //go:generate go run github.com/fjl/gencodec -type ExecutableDataV1 -field-override executableDataMarshaling -out gen_ed.go
 
 // ExecutableDataV1 structure described at https://github.com/ethereum/execution-apis/src/engine/specification.md
@@ -127,7 +138,7 @@ type ForkchoiceStateV1 struct {
 func encodeTransactions(txs []*types.Transaction) [][]byte {
 	var enc = make([][]byte, len(txs))
 	for i, tx := range txs {
-		enc[i], _ = tx.MarshalBinary()
+		enc[i], _ = tx.MarshalMinimal()
 	}
 	return enc
 }
@@ -182,10 +193,27 @@ func ExecutableDataToBlock(params ExecutableDataV1) (*types.Block, error) {
 	return block, nil
 }
 
-// BlockToExecutableData constructs the executableDataV1 structure by filling the
+// BlockToWrappedExecutableData constructs the executableDataV1 structure by filling the
 // fields from the given block. It assumes the given block is post-merge block.
-func BlockToExecutableData(block *types.Block) *ExecutableDataV1 {
-	return &ExecutableDataV1{
+// Additional wrapper contents are provided as well.
+func BlockToWrappedExecutableData(block *types.Block) (*ExecutableDataV1, *ExecutionWrapperV1) {
+	txs := encodeTransactions(block.Transactions())
+	wrapData := &ExecutionWrapperV1{Blobs: make(map[common.Hash]*BlobDetailsV1)}
+	for _, tx := range block.Transactions() {
+		if tx.Type() == types.BlobTxType {
+			versionedHashes, kzgs, blobs := tx.BlobWrapData()
+			for i, h := range versionedHashes {
+				if len(blobs) < i || len(kzgs) < i {
+					// oh no, we lost our wrapper data for the versioned hash,
+					// we set it to nil and hope the caller builds a new block.
+					wrapData.Blobs[h] = nil
+				} else {
+					wrapData.Blobs[h] = &BlobDetailsV1{Blob: blobs[i], KZG: kzgs[i]}
+				}
+			}
+		}
+	}
+	execData := &ExecutableDataV1{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
 		FeeRecipient:  block.Coinbase(),
@@ -197,8 +225,9 @@ func BlockToExecutableData(block *types.Block) *ExecutableDataV1 {
 		Timestamp:     block.Time(),
 		ReceiptsRoot:  block.ReceiptHash(),
 		LogsBloom:     block.Bloom().Bytes(),
-		Transactions:  encodeTransactions(block.Transactions()),
+		Transactions:  txs,
 		Random:        block.MixDigest(),
 		ExtraData:     block.Extra(),
 	}
+	return execData, wrapData
 }

core/bench_test.go

@@ -85,7 +85,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 	return func(i int, gen *BlockGen) {
 		toaddr := common.Address{}
 		data := make([]byte, nbytes)
-		gas, _ := IntrinsicGas(data, nil, false, false, false)
+		gas, _ := IntrinsicGas(data, nil, 0, false, false, false)
 		signer := types.MakeSigner(gen.config, big.NewInt(int64(i)))
 		gasPrice := big.NewInt(0)
 		if gen.header.BaseFee != nil {

core/blockchain_test.go

@@ -41,6 +41,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
+	"github.com/protolambda/ztyp/view"
 )
 
 // So we can deterministically seed different blockchains
@@ -3704,3 +3705,87 @@ func TestEIP1559Transition(t *testing.T) {
 		t.Fatalf("sender balance incorrect: expected %d, got %d", expected, actual)
 	}
 }
+
+// TestDataBlobTxs tests the following:
+//
+// 1. Writes data hash from transaction to storage.
+func TestDataBlobTxs(t *testing.T) {
+	var (
+		one = common.Hash{1}
+		two = common.Hash{2}
+		aa  = common.HexToAddress("0x000000000000000000000000000000000000aaaa")
+
+		// Generate a canonical chain to act as the main dataset
+		engine = ethash.NewFaker()
+		db     = rawdb.NewMemoryDatabase()
+
+		// A sender who makes transactions, has some funds
+		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
+		funds   = new(big.Int).Mul(common.Big1, big.NewInt(params.Ether))
+		gspec   = &Genesis{
+			Config: params.AllEthashProtocolChanges,
+			Alloc: GenesisAlloc{
+				addr1: {Balance: funds},
+				// The address 0xAAAA writes dataHashes[1] to storage slot 0x0.
+				aa: {
+					Code: []byte{
+						byte(vm.PUSH1),
+						byte(0x1),
+						byte(vm.DATAHASH),
+						byte(vm.PUSH1),
+						byte(0x0),
+						byte(vm.SSTORE),
+					},
+					Nonce:   0,
+					Balance: big.NewInt(0),
+				},
+			},
+		}
+	)
+
+	gspec.Config.BerlinBlock = common.Big0
+	gspec.Config.LondonBlock = common.Big0
+	gspec.Config.ShardingForkBlock = common.Big0
+	genesis := gspec.MustCommit(db)
+	signer := types.LatestSigner(gspec.Config)
+
+	blocks, _ := GenerateChain(gspec.Config, genesis, engine, db, 1, func(i int, b *BlockGen) {
+		b.SetCoinbase(common.Address{1})
+		msg := types.BlobTxMessage{
+			Nonce: 0,
+			Gas:   500000,
+		}
+		msg.To.Address = (*types.AddressSSZ)(&aa)
+		msg.ChainID.SetFromBig((*big.Int)(gspec.Config.ChainID))
+		msg.Nonce = view.Uint64View(0)
+		msg.GasFeeCap.SetFromBig(newGwei(5))
+		msg.GasTipCap.SetFromBig(big.NewInt(2))
+		msg.BlobVersionedHashes = []common.Hash{one, two}
+		txdata := &types.SignedBlobTx{Message: msg}
+
+		tx := types.NewTx(txdata)
+		tx, _ = types.SignTx(tx, signer, key1)
+
+		b.AddTx(tx)
+	})
+
+	diskdb := rawdb.NewMemoryDatabase()
+	gspec.MustCommit(diskdb)
+
+	chain, err := NewBlockChain(diskdb, nil, gspec.Config, engine, vm.Config{}, nil, nil)
+	if err != nil {
+		t.Fatalf("failed to create tester chain: %v", err)
+	}
+	if n, err := chain.InsertChain(blocks); err != nil {
+		t.Fatalf("block %d: failed to insert into chain: %v", n, err)
+	}
+
+	state, _ := chain.State()
+
+	// 1. Check that the storage slot is set to dataHashes[1].
+	actual := state.GetState(aa, common.Hash{0})
+	if actual != two {
+		t.Fatalf("incorrect data hash written to state (want: %s, got: %s)", two, actual)
+	}
+}

core/evm.go

@@ -72,8 +72,9 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common
 // NewEVMTxContext creates a new transaction context for a single transaction.
 func NewEVMTxContext(msg Message) vm.TxContext {
 	return vm.TxContext{
-		Origin:   msg.From(),
-		GasPrice: new(big.Int).Set(msg.GasPrice()),
+		Origin:     msg.From(),
+		GasPrice:   new(big.Int).Set(msg.GasPrice()),
+		DataHashes: msg.DataHashes(),
 	}
 }
 

core/state_transition.go

@@ -77,6 +77,7 @@ type Message interface {
 	IsFake() bool
 	Data() []byte
 	AccessList() types.AccessList
+	DataHashes() []common.Hash
 }
 
 // ExecutionResult includes all output after executing given evm
@@ -115,7 +116,7 @@ func (result *ExecutionResult) Revert() []byte {
 }
 
 // IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
-func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation bool, isHomestead, isEIP2028 bool) (uint64, error) {
+func IntrinsicGas(data []byte, accessList types.AccessList, blobCount int, isContractCreation bool, isHomestead, isEIP2028 bool) (uint64, error) {
 	// Set the starting gas for the raw transaction
 	var gas uint64
 	if isContractCreation && isHomestead {
@@ -152,6 +153,7 @@ func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation b
 		gas += uint64(len(accessList)) * params.TxAccessListAddressGas
 		gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas
 	}
+	gas += uint64(blobCount) * params.BlobGas
 	return gas, nil
 }
 
@@ -295,7 +297,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	contractCreation := msg.To() == nil
 
 	// Check clauses 4-5, subtract intrinsic gas if everything is correct
-	gas, err := IntrinsicGas(st.data, st.msg.AccessList(), contractCreation, homestead, istanbul)
+	gas, err := IntrinsicGas(st.data, st.msg.AccessList(), len(st.msg.DataHashes()), contractCreation, homestead, istanbul)
 	if err != nil {
 		return nil, err
 	}

core/tx_pool.go

@@ -51,6 +51,10 @@ const (
 	// more expensive to propagate; larger transactions also take more resources
 	// to validate whether they fit into the pool or not.
 	txMaxSize = 4 * txSlotSize // 128KB
+
+	// txWrapDataMax is the maximum size for the additional wrapper data,
+	// enough to encode a blob-transaction wrapper data (48 bytes for commitment, 4 for offset, 48 for a commitment)
+	txWrapDataMax = 4 + 4 + params.MaxBlobsPerTx*(params.FieldElementsPerBlob*32+48)
 )
 
 var (
@@ -85,6 +89,9 @@ var (
 	// than some meaningful limit a user might use. This is not a consensus error
 	// making the transaction invalid, rather a DOS protection.
 	ErrOversizedData = errors.New("oversized data")
+
+	// ErrBadWrapData is returned if wrap data is not valid for the transaction
+	ErrBadWrapData = errors.New("bad wrap data")
 )
 
 var (
@@ -244,6 +251,8 @@ type TxPool struct {
 	eip2718  bool // Fork indicator whether we are using EIP-2718 type transactions.
 	eip1559  bool // Fork indicator whether we are using EIP-1559 type transactions.
 
+	eipDataBlobs bool // Fork indicator whether we are using data blobs (mini danksharding)
+
 	currentState  *state.StateDB // Current state in the blockchain head
 	pendingNonces *txNoncer      // Pending state tracking virtual nonces
 	currentMaxGas uint64         // Current gas limit for transaction caps
@@ -592,10 +601,19 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if !pool.eip1559 && tx.Type() == types.DynamicFeeTxType {
 		return ErrTxTypeNotSupported
 	}
-	// Reject transactions over defined size to prevent DOS attacks
+	// Reject data blob transactions until data blob EIP activates.
+	if !pool.eipDataBlobs && tx.Type() == types.BlobTxType {
+		return ErrTxTypeNotSupported
+	}
+	// Reject transactions over defined size to prevent DOS attacks.
+	// Even if it is a blob-tx, the tx without blob-data still needs to be under the strict txMaxSize limit.
 	if uint64(tx.Size()) > txMaxSize {
 		return ErrOversizedData
 	}
+	// Reject transactions that have too much wrap data to prevent DOS attacks.
+	if uint64(tx.WrapDataSize()) > txWrapDataMax {
+		return ErrOversizedData
+	}
 	// Transactions can't be negative. This may never happen using RLP decoded
 	// transactions but may occur if you create a transaction using the RPC.
 	if tx.Value().Sign() < 0 {
@@ -635,13 +653,17 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		return ErrInsufficientFunds
 	}
 	// Ensure the transaction has more gas than the basic tx fee.
-	intrGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, true, pool.istanbul)
+	intrGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), 0, tx.To() == nil, true, pool.istanbul)
 	if err != nil {
 		return err
 	}
 	if tx.Gas() < intrGas {
 		return ErrIntrinsicGas
 	}
+	// Check if wrap data is valid
+	if err := tx.CheckWrapData(); err != nil {
+		return ErrBadWrapData
+	}
 	return nil
 }
 
@@ -1271,6 +1293,16 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 						log.Error("Unrooted old chain seen by tx pool", "block", oldHead.Number, "hash", oldHead.Hash())
 						return
 					}
+					// transactions that contained blobs might not have the wrapData anymore
+					// if not retrieved from block cache since wrap data is not persisted. Discord those.
+					j := 0
+					for _, tx := range discarded {
+						if !tx.IsIncomplete() {
+							discarded[j] = tx
+							j++
+						}
+					}
+					discarded = discarded[:j]
 					included = append(included, add.Transactions()...)
 					if add = pool.chain.GetBlock(add.ParentHash(), add.NumberU64()-1); add == nil {
 						log.Error("Unrooted new chain seen by tx pool", "block", newHead.Number, "hash", newHead.Hash())
@@ -1304,6 +1336,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 	pool.istanbul = pool.chainconfig.IsIstanbul(next)
 	pool.eip2718 = pool.chainconfig.IsBerlin(next)
 	pool.eip1559 = pool.chainconfig.IsLondon(next)
+	pool.eipDataBlobs = pool.chainconfig.IsSharding(next)
 }
 
 // promoteExecutables moves transactions that have become processable from the