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

@@ -1,17 +1,26 @@
 package types
 
 import (
+	"bytes"
 	"context"
 	"encoding/binary"
+	"errors"
+	"io"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/ethereum/go-ethereum/common"
 )
 
+const (
+	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 +525,91 @@ 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 (tx *ArbitrumSubtypedTx) EncodeRLP(w io.Writer) error {
+	buf := encodeBufferPool.Get().(*bytes.Buffer)
+	defer encodeBufferPool.Put(buf)
+	buf.Reset()
+	buf.WriteByte(tx.TxSubtype())
+	if err := rlp.Encode(buf, tx.TxData); err != nil {
+		return err
+	}
+	return rlp.Encode(w, buf.Bytes())
+}
+
+func (tx *ArbitrumSubtypedTx) DecodeRLP(s *rlp.Stream) error {
+	b, err := s.Bytes()
+	if err != nil {
+		return err
+	}
+	if len(b) < 1 {
+		return errShortTypedTx
+	}
+	switch b[0] {
+	case ArbitrumTippingTxSubtype:
+		var tipping ArbitrumTippingTx
+		err := rlp.DecodeBytes(b[1:], &tipping)
+		tx.TxData = &tipping
+		return err
+	default:
+		return ErrTxTypeNotSupported
+	}
+}
+
+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 }
+
+func (tx *ArbitrumTippingTx) EncodeRLP(w io.Writer) error {
+	return rlp.Encode(w, tx.DynamicFeeTx)
+}
+
+func (tx *ArbitrumTippingTx) DecodeRLP(s *rlp.Stream) error {
+	var dynamic DynamicFeeTx
+	err := s.Decode(&dynamic)
+	tx.DynamicFeeTx = dynamic
+	return err
+}

core/types/arbitrum_signer.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -40,6 +41,20 @@ func (s arbitrumSigner) Sender(tx *Transaction) (common.Address, error) {
 		}
 		fakeTx := NewTx(&legacyData.LegacyTx)
 		return s.Signer.Sender(fakeTx)
+	case *ArbitrumSubtypedTx:
+		switch inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			V, R, S := tx.RawSignatureValues()
+			// DynamicFee txs are defined to use 0 and 1 as their recovery
+			// id, add 27 to become equivalent to unprotected Homestead signatures.
+			V = new(big.Int).Add(V, big.NewInt(27))
+			if tx.ChainId().Cmp(s.Signer.ChainID()) != 0 {
+				return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.Signer.ChainID())
+			}
+			return recoverPlain(s.Hash(tx), R, S, V, true)
+		default:
+			return common.Address{}, ErrTxTypeNotSupported
+		}
 	default:
 		return s.Signer.Sender(tx)
 	}
@@ -51,7 +66,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 +80,22 @@ 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 txdata := inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			// Check that chain ID of tx matches the signer. We also accept ID zero here,
+			// because it indicates that the chain ID was not specified in the tx.
+			if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.Signer.ChainID()) != 0 {
+				return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.Signer.ChainID())
+			}
+			R, S, _ = decodeSignature(sig)
+			V = big.NewInt(int64(sig[64]))
+			return R, S, V, nil
+		default:
+			return nil, nil, nil, ErrTxTypeNotSupported
+		}
 	default:
 		return s.Signer.SignatureValues(tx, sig)
 	}
@@ -76,9 +104,28 @@ 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 inner.TxData.(type) {
+		case *ArbitrumTippingTx:
+			return prefixedRlpHash(
+				tx.Type(),
+				[]interface{}{
+					inner.TxSubtype(),
+					s.Signer.ChainID(),
+					tx.Nonce(),
+					tx.GasTipCap(),
+					tx.GasFeeCap(),
+					tx.Gas(),
+					tx.To(),
+					tx.Value(),
+					tx.Data(),
+					tx.AccessList(),
+				})
+		}
 	}
 	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.
@@ -244,6 +244,10 @@ func (tx *Transaction) decodeTyped(b []byte, arbParsing bool) (TxData, error) {
 		var inner BlobTx
 		err := rlp.DecodeBytes(b[1:], &inner)
 		return &inner, err
+	case ArbitrumSubtypedTxType:
+		var inner ArbitrumSubtypedTx
+		err := rlp.DecodeBytes(b[1:], &inner)
+		return &inner, err
 	default:
 		return nil, ErrTxTypeNotSupported
 	}