Flexible BlobTx JSON codec

This patch removes the requirement of Blob transactions JSON (un)marshaling to contain data.
JSON-encoded blob txs returned by JSON-RPC needs this in order to serve
transactions from the block body. Otherwise, the marshaling fails as
we only persist the minimal representation of transactions in block bodies.

We do not use JSON internally for tx message passing. This only affects
JSON-RPC and external APIs.

Author: Inphi

core/types/transaction_marshalling.go

@@ -118,12 +118,11 @@ func (t *Transaction) MarshalJSON() ([]byte, error) {
 		enc.R = (*hexutil.Big)(r)
 		enc.S = (*hexutil.Big)(s)
 		enc.BlobVersionedHashes = tx.Message.BlobVersionedHashes
-		if t.wrapData == nil {
-			return nil, fmt.Errorf("expected wrap-data for blob tx")
+		if t.wrapData != nil {
+			enc.Blobs = t.wrapData.blobs()
+			enc.BlobKzgs = t.wrapData.kzgs()
+			enc.KzgAggregatedProof = t.wrapData.aggregatedProof()
 		}
-		enc.Blobs = t.wrapData.blobs()
-		enc.BlobKzgs = t.wrapData.kzgs()
-		enc.KzgAggregatedProof = t.wrapData.aggregatedProof()
 	}
 	return json.Marshal(&enc)
 }
@@ -349,14 +348,17 @@ func (t *Transaction) UnmarshalJSON(input []byte) error {
 			}
 		}
 		itx.Message.BlobVersionedHashes = dec.BlobVersionedHashes
-		t.wrapData = &BlobTxWrapData{
-			BlobKzgs:           dec.BlobKzgs,
-			Blobs:              dec.Blobs,
-			KzgAggregatedProof: dec.KzgAggregatedProof,
-		}
-		// Verify that versioned hashes match kzgs, and kzgs match blobs.
-		if err := t.wrapData.verifyBlobs(&itx); err != nil {
-			return fmt.Errorf("blob wrapping data is invalid: %v", err)
+		// A BlobTx may not contain data
+		if len(dec.Blobs) != 0 || len(dec.BlobKzgs) != 0 {
+			t.wrapData = &BlobTxWrapData{
+				BlobKzgs:           dec.BlobKzgs,
+				Blobs:              dec.Blobs,
+				KzgAggregatedProof: dec.KzgAggregatedProof,
+			}
+			// Verify that versioned hashes match kzgs, and kzgs match blobs.
+			if err := t.wrapData.verifyBlobs(&itx); err != nil {
+				return fmt.Errorf("blob wrapping data is invalid: %v", err)
+			}
 		}
 	default:
 		return ErrTxTypeNotSupported

core/types/transaction_test.go

@@ -28,6 +28,7 @@ import (
 	"time"
 
 	"github.com/holiman/uint256"
+	"github.com/protolambda/go-kzg/bls"
 	"github.com/protolambda/ztyp/view"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -491,10 +492,12 @@ func TestTransactionCoding(t *testing.T) {
 					BlobVersionedHashes: VersionedHashesView{common.HexToHash("0x01624652859a6e98ffc1608e2af0147ca4e86e1ce27672d8d3f3c9d4ffd6ef7e")},
 				},
 			}
+			var kzgProof KZGProof
+			copy(kzgProof[:], bls.ToCompressedG1((*bls.G1Point)(&bls.ZeroG1)))
 			wrapData = &BlobTxWrapData{
 				BlobKzgs:           BlobKzgs{KZGCommitment{0: 0xc0}},
 				Blobs:              Blobs{Blob{}},
-				KzgAggregatedProof: KZGProof{0: 0xd0},
+				KzgAggregatedProof: kzgProof,
 			}
 		}
 		tx, err := SignNewTx(key, signer, txdata, WithTxWrapData(wrapData))
@@ -521,6 +524,41 @@ func TestTransactionCoding(t *testing.T) {
 	}
 }
 
+func TestBlobTransactionMinimalCodec(t *testing.T) {
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("could not generate key: %v", err)
+	}
+	var (
+		signer   = NewDankSigner(common.Big1)
+		addr     = common.HexToAddress("0x0000000000000000000000000000000000000001")
+		accesses = AccessList{{Address: addr, StorageKeys: []common.Hash{{0}}}}
+	)
+
+	txdata := &SignedBlobTx{
+		Message: BlobTxMessage{
+			ChainID:             view.Uint256View(*uint256.NewInt(1)),
+			Nonce:               view.Uint64View(1),
+			Gas:                 view.Uint64View(123457),
+			GasTipCap:           view.Uint256View(*uint256.NewInt(42)),
+			GasFeeCap:           view.Uint256View(*uint256.NewInt(10)),
+			AccessList:          AccessListView(accesses),
+			BlobVersionedHashes: VersionedHashesView{common.HexToHash("0x01624652859a6e98ffc1608e2af0147ca4e86e1ce27672d8d3f3c9d4ffd6ef7e")},
+		},
+	}
+	tx, err := SignNewTx(key, signer, txdata)
+	if err != nil {
+		t.Fatalf("could not sign transaction: %v", err)
+	}
+	parsedTx, err := encodeDecodeJSON(tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := assertEqual(parsedTx, tx); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func encodeDecodeJSON(tx *Transaction) (*Transaction, error) {
 	data, err := json.Marshal(tx)
 	if err != nil {

core/types/types_test.go

@@ -75,14 +75,14 @@ func benchRLP(b *testing.B, encode bool) {
 		{
 			"protodanksharding-header",
 			&Header{
-				Difficulty: big.NewInt(10000000000),
-				Number:     big.NewInt(1000),
-				GasLimit:   8_000_000,
-				GasUsed:    8_000_000,
-				Time:       555,
-				Extra:      make([]byte, 32),
-				BaseFee:    big.NewInt(10000000000),
-				Blobs:      2,
+				Difficulty:  big.NewInt(10000000000),
+				Number:      big.NewInt(1000),
+				GasLimit:    8_000_000,
+				GasUsed:     8_000_000,
+				Time:        555,
+				Extra:       make([]byte, 32),
+				BaseFee:     big.NewInt(10000000000),
+				ExcessBlobs: 2,
 			},
 		},
 		{

internal/ethapi/api.go

@@ -1178,7 +1178,7 @@ func RPCMarshalHeader(head *types.Header) map[string]interface{} {
 		"timestamp":        hexutil.Uint64(head.Time),
 		"transactionsRoot": head.TxHash,
 		"receiptsRoot":     head.ReceiptHash,
-		"excessBlobs":      head.ExcessBlobs,
+		"excessBlobs":      hexutil.Uint64(head.ExcessBlobs),
 	}
 
 	if head.BaseFee != nil {
@@ -1305,7 +1305,7 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber
 		al := tx.AccessList()
 		result.Accesses = &al
 		result.ChainID = (*hexutil.Big)(tx.ChainId())
-	case types.DynamicFeeTxType:
+	case types.DynamicFeeTxType, types.BlobTxType:
 		al := tx.AccessList()
 		result.Accesses = &al
 		result.ChainID = (*hexutil.Big)(tx.ChainId())