Add tipping tx subtype

accounts/external/backend.go

@@ -218,6 +218,11 @@ 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.ArbitrumSubtypedTxType:
+		if types.GetArbitrumTxSubtype(tx) == types.ArbitrumTippingTxSubtype {
+			args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
+			args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+		}
 	default:
 		return nil, fmt.Errorf("unsupported tx type %d", tx.Type())
 	}

core/types/arb_types.go

@@ -3,6 +3,7 @@ package types
 import (
 	"context"
 	"encoding/binary"
+	"errors"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -12,6 +13,12 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+const (
+	arbitrumSubtypeOffset    = 0xff
+	ArbitrumInvalidSubtype   = 0
+	ArbitrumTippingTxSubtype = 1
+)
+
 // Returns true if nonce checks should be skipped based on inner's isFake()
 // This also disables requiring that sender is an EOA and not a contract
 func (tx *Transaction) SkipAccountChecks() bool {
@@ -516,3 +523,50 @@ func DeserializeHeaderExtraInformation(header *Header) HeaderInfo {
 	extra.ArbOSFormatVersion = binary.BigEndian.Uint64(header.MixDigest[16:24])
 	return extra
 }
+
+type ArbitrumSubtypedTx struct {
+	TxData
+}
+
+func (tx *ArbitrumSubtypedTx) copy() TxData {
+	return &ArbitrumSubtypedTx{
+		TxData: tx.TxData.copy(),
+	}
+}
+
+func (tx *ArbitrumSubtypedTx) txType() byte    { return ArbitrumSubtypedTxType }
+func (tx *ArbitrumSubtypedTx) TxSubtype() byte { return tx.TxData.txType() }
+
+func GetArbitrumTxSubtype(tx *Transaction) byte {
+	switch inner := tx.inner.(type) {
+	case *ArbitrumSubtypedTx:
+		return inner.TxSubtype()
+	default:
+		return ArbitrumInvalidSubtype
+	}
+}
+
+type ArbitrumTippingTx struct {
+	DynamicFeeTx
+}
+
+func NewArbitrumTippingTx(origTx *Transaction) (*Transaction, error) {
+	dynamicPtr, ok := origTx.GetInner().(*DynamicFeeTx)
+	if origTx.Type() != DynamicFeeTxType || !ok {
+		return nil, errors.New("attempt to arbitrum-wrap into tipping transaction a transaction that is not a dynamic fee transaction")
+	}
+	inner := ArbitrumSubtypedTx{
+		TxData: &ArbitrumTippingTx{
+			DynamicFeeTx: *dynamicPtr,
+		}}
+	return NewTx(&inner), nil
+}
+
+func (tx *ArbitrumTippingTx) copy() TxData {
+	dynamicCopy := tx.DynamicFeeTx.copy().(*DynamicFeeTx)
+	return &ArbitrumTippingTx{
+		DynamicFeeTx: *dynamicCopy,
+	}
+}
+
+func (tx *ArbitrumTippingTx) txType() byte { return ArbitrumTippingTxSubtype }

core/types/arbitrum_signer.go

@@ -40,6 +40,14 @@ func (s arbitrumSigner) Sender(tx *Transaction) (common.Address, error) {
 		}
 		fakeTx := NewTx(&legacyData.LegacyTx)
 		return s.Signer.Sender(fakeTx)
+	case *ArbitrumSubtypedTx:
+		switch subtx := inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			fakeTx := NewTx(&subtx.DynamicFeeTx)
+			return s.Signer.Sender(fakeTx)
+		default:
+			return common.Address{}, ErrTxTypeNotSupported
+		}
 	default:
 		return s.Signer.Sender(tx)
 	}
@@ -51,7 +59,7 @@ func (s arbitrumSigner) Equal(s2 Signer) bool {
 }
 
 func (s arbitrumSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) {
-	switch tx.inner.(type) {
+	switch inner := tx.inner.(type) {
 	case *ArbitrumUnsignedTx:
 		return bigZero, bigZero, bigZero, nil
 	case *ArbitrumContractTx:
@@ -65,9 +73,16 @@ func (s arbitrumSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *b
 	case *ArbitrumSubmitRetryableTx:
 		return bigZero, bigZero, bigZero, nil
 	case *ArbitrumLegacyTxData:
-		legacyData := tx.inner.(*ArbitrumLegacyTxData)
-		fakeTx := NewTx(&legacyData.LegacyTx)
+		fakeTx := NewTx(&inner.LegacyTx)
 		return s.Signer.SignatureValues(fakeTx, sig)
+	case *ArbitrumSubtypedTx:
+		switch subtx := inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			fakeTx := NewTx(&subtx.DynamicFeeTx)
+			return s.Signer.SignatureValues(fakeTx, sig)
+		default:
+			return nil, nil, nil, ErrTxTypeNotSupported
+		}
 	default:
 		return s.Signer.SignatureValues(tx, sig)
 	}
@@ -76,9 +91,16 @@ func (s arbitrumSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *b
 // Hash returns the hash to be signed by the sender.
 // It does not uniquely identify the transaction.
 func (s arbitrumSigner) Hash(tx *Transaction) common.Hash {
-	if legacyData, isArbLegacy := tx.inner.(*ArbitrumLegacyTxData); isArbLegacy {
-		fakeTx := NewTx(&legacyData.LegacyTx)
+	switch inner := tx.inner.(type) {
+	case *ArbitrumLegacyTxData:
+		fakeTx := NewTx(&inner.LegacyTx)
 		return s.Signer.Hash(fakeTx)
+	case *ArbitrumSubtypedTx:
+		switch subtx := inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			fakeTx := NewTx(&subtx.DynamicFeeTx)
+			return s.Signer.Hash(fakeTx)
+		}
 	}
 	return s.Signer.Hash(tx)
 }

core/types/transaction.go

@@ -41,18 +41,18 @@ var (
 
 // Transaction types.
 const (
-	ArbitrumDepositTxType         = 0x64
-	ArbitrumUnsignedTxType        = 0x65
-	ArbitrumContractTxType        = 0x66
-	ArbitrumRetryTxType           = 0x68
-	ArbitrumSubmitRetryableTxType = 0x69
-	ArbitrumInternalTxType        = 0x6A
-	ArbitrumLegacyTxType          = 0x78
-
-	LegacyTxType     = 0x00
-	AccessListTxType = 0x01
-	DynamicFeeTxType = 0x02
-	BlobTxType       = 0x03
+	ArbitrumSubtypedTxType        = 99
+	ArbitrumDepositTxType         = 100
+	ArbitrumUnsignedTxType        = 101
+	ArbitrumContractTxType        = 102
+	ArbitrumRetryTxType           = 104
+	ArbitrumSubmitRetryableTxType = 105
+	ArbitrumInternalTxType        = 106
+	ArbitrumLegacyTxType          = 120
+	LegacyTxType                  = 0x00
+	AccessListTxType              = 0x01
+	DynamicFeeTxType              = 0x02
+	BlobTxType                    = 0x03
 )
 
 // Transaction is an Ethereum transaction.
@@ -128,6 +128,11 @@ func (tx *Transaction) EncodeRLP(w io.Writer) error {
 
 // encodeTyped writes the canonical encoding of a typed transaction to w.
 func (tx *Transaction) encodeTyped(w *bytes.Buffer) error {
+	if tx.Type() == ArbitrumSubtypedTxType {
+		w.WriteByte(tx.Type())
+		w.WriteByte(tx.inner.(*ArbitrumSubtypedTx).TxSubtype())
+		return rlp.Encode(w, tx.inner.(*ArbitrumSubtypedTx).TxData)
+	}
 	w.WriteByte(tx.Type())
 	return rlp.Encode(w, tx.inner)
 }
@@ -199,6 +204,22 @@ func (tx *Transaction) decodeTyped(b []byte, arbParsing bool) (TxData, error) {
 	if len(b) <= 1 {
 		return nil, errShortTypedTx
 	}
+	txType := uint64(b[0])
+	if txType == ArbitrumSubtypedTxType {
+		if len(b) <= 2 {
+			return nil, errShortTypedTx
+		}
+		var inner ArbitrumSubtypedTx
+		switch b[1] {
+		case ArbitrumTippingTxSubtype:
+			var tipping ArbitrumTippingTx
+			err := rlp.DecodeBytes(b[2:], &tipping)
+			inner.TxData = &tipping
+			return &inner, err
+		default:
+			return nil, ErrTxTypeNotSupported
+		}
+	}
 	if arbParsing {
 		switch b[0] {
 		case ArbitrumDepositTxType:

core/types/transaction_marshalling.go

@@ -48,6 +48,7 @@ type txJSON struct {
 	YParity              *hexutil.Uint64 `json:"yParity,omitempty"`
 
 	// Arbitrum fields:
+	Subtype             *hexutil.Uint64 `json:"subtype,omitempty"`             // ArbitrumSubtypedTx
 	From                *common.Address `json:"from,omitempty"`                // Contract SubmitRetryable Unsigned Retry
 	RequestId           *common.Hash    `json:"requestId,omitempty"`           // Contract SubmitRetryable Deposit
 	TicketId            *common.Hash    `json:"ticketId,omitempty"`            // Retry
@@ -223,7 +224,29 @@ func (tx *Transaction) MarshalJSON() ([]byte, error) {
 		data := itx.data()
 		enc.Input = (*hexutil.Bytes)(&data)
 		enc.To = tx.To()
-
+	case *ArbitrumSubtypedTx:
+		subtype := uint64(itx.TxSubtype())
+		enc.Subtype = (*hexutil.Uint64)(&subtype)
+		switch subtype {
+		case ArbitrumTippingTxSubtype:
+			enc.ChainID = (*hexutil.Big)(itx.chainID())
+			accessList := itx.accessList()
+			enc.AccessList = &accessList
+			nonce := itx.nonce()
+			enc.Nonce = (*hexutil.Uint64)(&nonce)
+			gas := itx.gas()
+			enc.Gas = (*hexutil.Uint64)(&gas)
+			enc.MaxFeePerGas = (*hexutil.Big)(itx.gasFeeCap())
+			enc.MaxPriorityFeePerGas = (*hexutil.Big)(itx.gasTipCap())
+			enc.Value = (*hexutil.Big)(itx.value())
+			data := itx.data()
+			enc.Input = (*hexutil.Bytes)(&data)
+			enc.To = tx.To()
+			v, r, s := itx.rawSignatureValues()
+			enc.V = (*hexutil.Big)(v)
+			enc.R = (*hexutil.Big)(r)
+			enc.S = (*hexutil.Big)(s)
+		}
 	case *BlobTx:
 		enc.ChainID = (*hexutil.Big)(itx.ChainID.ToBig())
 		enc.Nonce = (*hexutil.Uint64)(&itx.Nonce)
@@ -255,7 +278,15 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 
 	// Decode / verify fields according to transaction type.
 	var inner TxData
-	switch dec.Type {
+	decType := uint64(dec.Type)
+	if decType == ArbitrumSubtypedTxType {
+		if dec.Subtype != nil {
+			decType = uint64(*dec.Subtype) + arbitrumSubtypeOffset
+		} else {
+			return errors.New("missing required field 'subtype' in transaction")
+		}
+	}
+	switch decType {
 	case LegacyTxType:
 		var itx LegacyTx
 		inner = &itx
@@ -359,9 +390,12 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 			}
 		}
 
-	case DynamicFeeTxType:
+	case DynamicFeeTxType, ArbitrumTippingTxSubtype + arbitrumSubtypeOffset:
 		var itx DynamicFeeTx
-		inner = &itx
+		// Access list is optional for now.
+		if dec.AccessList != nil {
+			itx.AccessList = *dec.AccessList
+		}
 		if dec.ChainID == nil {
 			return errors.New("missing required field 'chainId' in transaction")
 		}
@@ -420,6 +454,15 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 				return err
 			}
 		}
+		if decType == ArbitrumTippingTxSubtype+arbitrumSubtypeOffset {
+			inner = &ArbitrumSubtypedTx{
+				TxData: &ArbitrumTippingTx{
+					DynamicFeeTx: itx,
+				},
+			}
+		} else {
+			inner = &itx
+		}
 
 	case ArbitrumLegacyTxType:
 		var itx LegacyTx

internal/ethapi/api.go

@@ -1521,6 +1521,7 @@ type RPCTransaction struct {
 	YParity          *hexutil.Uint64   `json:"yParity,omitempty"`
 
 	// Arbitrum fields:
+	Subtype             hexutil.Uint64  `json:"subtype,omitempty"`             // ArbiturumSubtypedTx
 	RequestId           *common.Hash    `json:"requestId,omitempty"`           // Contract SubmitRetryable Deposit
 	TicketId            *common.Hash    `json:"ticketId,omitempty"`            // Retry
 	MaxRefund           *hexutil.Big    `json:"maxRefund,omitempty"`           // Retry
@@ -1625,6 +1626,25 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber
 		result.ChainID = (*hexutil.Big)(inner.ChainId)
 	case *types.ArbitrumUnsignedTx:
 		result.ChainID = (*hexutil.Big)(inner.ChainId)
+	case *types.ArbitrumSubtypedTx:
+		subtype := inner.TxSubtype()
+		result.Subtype = hexutil.Uint64(subtype)
+		switch subtype {
+		case types.ArbitrumTippingTxSubtype:
+			al := tx.AccessList()
+			result.Accesses = &al
+			result.ChainID = (*hexutil.Big)(tx.ChainId())
+			result.GasFeeCap = (*hexutil.Big)(tx.GasFeeCap())
+			result.GasTipCap = (*hexutil.Big)(tx.GasTipCap())
+			// if the transaction has been mined, compute the effective gas price
+			if baseFee != nil && blockHash != (common.Hash{}) {
+				// price = min(tip, gasFeeCap - baseFee) + baseFee
+				price := math.BigMin(new(big.Int).Add(tx.GasTipCap(), baseFee), tx.GasFeeCap())
+				result.GasPrice = (*hexutil.Big)(price)
+			} else {
+				result.GasPrice = (*hexutil.Big)(tx.GasFeeCap())
+			}
+		}
 	}
 	return result
 }

rlp/internal/rlpstruct/rlpstruct.go

@@ -79,6 +79,9 @@ type Tags struct {
 
 	// rlp:"-" ignores fields.
 	Ignored bool
+
+	// rlp:"flat" flattens field.
+	Flat bool
 }
 
 // TagError is raised for invalid struct tags.
@@ -183,6 +186,8 @@ func parseTag(field Field, lastPublic int) (Tags, error) {
 			if field.Type.Kind != reflect.Slice {
 				return ts, TagError{Field: name, Tag: t, Err: "field type is not slice"}
 			}
+		case "flat":
+			ts.Flat = true
 		default:
 			return ts, TagError{Field: name, Tag: t, Err: "unknown tag"}
 		}