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,14 @@ 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 := tx.BlobWrapData()
+		if len(hashes) != len(blobs) {
+			return nil, fmt.Errorf("missing blobs data, expected %d blobs", len(hashes))
+		}
+		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())
 	}

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,13 @@ type payloadAttributesMarshaling struct {
 	Timestamp hexutil.Uint64
 }
 
+// BlobsBundleV1 holds the blobs of an execution payload, to be retrieved separately
+type BlobsBundleV1 struct {
+	BlockHash common.Hash           `json:"blockHash"     gencodec:"required"`
+	KZGs      []types.KZGCommitment `json:"kzgs"      gencodec:"required"`
+	Blobs     []types.Blob          `json:"blobs"      gencodec:"required"`
+}
+
 //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 +134,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 +189,12 @@ 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 blob contents are provided as well.
+func BlockToWrappedExecutableData(block *types.Block) (*ExecutableDataV1, *BlobsBundleV1, error) {
+	txs := encodeTransactions(block.Transactions())
+	execData := &ExecutableDataV1{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
 		FeeRecipient:  block.Coinbase(),
@@ -197,8 +206,21 @@ 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(),
 	}
+	blobsBundle := &BlobsBundleV1{BlockHash: execData.BlockHash}
+	for i, tx := range block.Transactions() {
+		if tx.Type() == types.BlobTxType {
+			versionedHashes, kzgs, blobs := tx.BlobWrapData()
+			if len(versionedHashes) != len(kzgs) || len(versionedHashes) != len(blobs) {
+				return nil, nil, fmt.Errorf("tx %d in block %s has inconsistent blobs (%d) / kzgs (%d)"+
+					" / versioned hashes (%d)", i, execData.BlockHash, len(blobs), len(kzgs), len(versionedHashes))
+			}
+			blobsBundle.Blobs = append(blobsBundle.Blobs, blobs...)
+			blobsBundle.KZGs = append(blobsBundle.KZGs, kzgs...)
+		}
+	}
+	return execData, blobsBundle, nil
 }

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
 	}