TxnType is not returned in JSON-RPC response

jsonrpc/eth_endpoint_test.go

@@ -242,6 +242,59 @@ func TestEth_GetNextNonce(t *testing.T) {
 	}
 }
 
+func TestEth_TxnType(t *testing.T) {
+	// Set up the mock accounts
+	accounts := []struct {
+		address types.Address
+		account *Account
+	}{
+		{
+			types.StringToAddress("123"),
+			&Account{
+				Nonce: 5,
+			},
+		},
+	}
+
+	// Set up the mock store
+	store := newMockStore()
+	for _, acc := range accounts {
+		store.SetAccount(acc.address, acc.account)
+	}
+
+	// Setup Txn
+	args := &txnArgs{
+		From:      &addr1,
+		To:        &addr2,
+		Gas:       toArgUint64Ptr(21000),
+		GasPrice:  toArgBytesPtr(big.NewInt(10000).Bytes()),
+		GasTipCap: toArgBytesPtr(big.NewInt(10000).Bytes()),
+		GasFeeCap: toArgBytesPtr(big.NewInt(10000).Bytes()),
+		Value:     toArgBytesPtr(oneEther.Bytes()),
+		Data:      nil,
+		Nonce:     toArgUint64Ptr(0),
+		Type:      toArgUint64Ptr(uint64(types.DynamicFeeTx)),
+	}
+
+	expectedRes := &types.Transaction{
+		From:      addr1,
+		To:        &addr2,
+		Gas:       21000,
+		GasPrice:  big.NewInt(10000),
+		GasTipCap: big.NewInt(10000),
+		GasFeeCap: big.NewInt(10000),
+		Value:     oneEther,
+		Input:     []byte{},
+		Nonce:     0,
+		Type:      types.DynamicFeeTx,
+	}
+	res, err := DecodeTxn(args, store)
+
+	expectedRes.ComputeHash()
+	assert.NoError(t, err)
+	assert.Equal(t, expectedRes, res)
+}
+
 func newTestEthEndpoint(store testStore) *Eth {
 	return &Eth{
 		hclog.NewNullLogger(), store, 100, nil, 0,

jsonrpc/helper.go

@@ -216,6 +216,11 @@ func DecodeTxn(arg *txnArgs, store nonceGetter) (*types.Transaction, error) {
 		arg.Gas = argUintPtr(0)
 	}
 
+	txType := types.LegacyTx
+	if arg.Type != nil {
+		txType = types.TxType(*arg.Type)
+	}
+
 	txn := &types.Transaction{
 		From:      *arg.From,
 		Gas:       uint64(*arg.Gas),
@@ -225,6 +230,7 @@ func DecodeTxn(arg *txnArgs, store nonceGetter) (*types.Transaction, error) {
 		Value:     new(big.Int).SetBytes(*arg.Value),
 		Input:     input,
 		Nonce:     uint64(*arg.Nonce),
+		Type:      txType,
 	}
 
 	if arg.To != nil {

jsonrpc/testsuite/block-with-txn-bodies.json

@@ -32,7 +32,8 @@
             "from": "0x0300000000000000000000000000000000000000",
             "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
             "blockNumber": "0x1",
-            "transactionIndex": "0x2"
+            "transactionIndex": "0x2",
+            "type": "0x0"
         }
     ],
     "uncles": null,

jsonrpc/testsuite/transaction-eip1559.json

@@ -14,5 +14,6 @@
     "from": "0x0300000000000000000000000000000000000000",
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "blockNumber": "0x1",
-    "transactionIndex": "0x2"
+    "transactionIndex": "0x2",
+    "type": "0x2"
 }

jsonrpc/testsuite/transaction-pending.json

@@ -12,5 +12,6 @@
     "from": "0x0300000000000000000000000000000000000000",
     "blockHash": null,
     "blockNumber": null,
-    "transactionIndex": null
+    "transactionIndex": null,
+    "type": "0x0"
 }

jsonrpc/testsuite/transaction-sealed.json

@@ -12,5 +12,6 @@
     "from": "0x0300000000000000000000000000000000000000",
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "blockNumber": "0x1",
-    "transactionIndex": "0x2"
+    "transactionIndex": "0x2",
+    "type": "0x0"
 }

jsonrpc/types.go

@@ -31,6 +31,7 @@ type transaction struct {
 	BlockHash   *types.Hash    `json:"blockHash"`
 	BlockNumber *argUint64     `json:"blockNumber"`
 	TxIndex     *argUint64     `json:"transactionIndex"`
+	Type        argUint64      `json:"type"`
 }
 
 func (t transaction) getHash() types.Hash { return t.Hash }
@@ -66,6 +67,7 @@ func toTransaction(
 		S:        argBig(*t.S),
 		Hash:     t.Hash,
 		From:     t.From,
+		Type:     argUint64(t.Type),
 	}
 
 	if t.GasTipCap != nil {
@@ -331,6 +333,7 @@ type txnArgs struct {
 	Data      *argBytes
 	Input     *argBytes
 	Nonce     *argUint64
+	Type      *argUint64
 }
 
 type progression struct {

jsonrpc/types_test.go

@@ -219,6 +219,7 @@ func mockTxn() *transaction {
 		BlockHash:   &types.ZeroHash,
 		BlockNumber: argUintPtr(1),
 		TxIndex:     argUintPtr(2),
+		Type:        argUint64(types.LegacyTx),
 	}
 
 	return tt
@@ -256,6 +257,7 @@ func TestTransaction_Encoding(t *testing.T) {
 		tt := mockTxn()
 		tt.GasTipCap = &gasTipCap
 		tt.GasFeeCap = &gasFeeCap
+		tt.Type = argUint64(types.DynamicFeeTx)
 
 		testTransaction("testsuite/transaction-eip1559.json", tt)
 	})