Celo Denominated tx type and receipt

accounts/external/backend.go

@@ -215,7 +215,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
  switch tx.Type() {
  case types.LegacyTxType, types.AccessListTxType:
  args.GasPrice = (*hexutil.Big)(tx.GasPrice())
- case types.DynamicFeeTxType, types.CeloDynamicFeeTxType:
+ case types.DynamicFeeTxType, types.CeloDynamicFeeTxType, types.CeloDenominatedTxType:
  args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
  args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
  default:

core/txpool/legacypool/legacypool.go

@@ -287,7 +287,7 @@ func New(config Config, chain BlockChain) *LegacyPool {
 // pool, specifically, whether it is a Legacy, AccessList or Dynamic transaction.
 func (pool *LegacyPool) Filter(tx *types.Transaction) bool {
  switch tx.Type() {
- case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.CeloDynamicFeeTxType:
+ case types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType, types.CeloDynamicFeeTxType, types.CeloDenominatedTxType:
  return true
  default:
  return false
@@ -626,7 +626,8 @@ func (pool *LegacyPool) validateTxBasics(tx *types.Transaction, local bool) erro
  types.LegacyTxType,
  types.AccessListTxType,
  types.DynamicFeeTxType,
- types.CeloDynamicFeeTxType),
+ types.CeloDynamicFeeTxType,
+ types.CeloDenominatedTxType),
  MaxSize: txMaxSize,
  MinTip: pool.gasTip.Load(),
  }

core/types/celo_denominated_tx.go

@@ -0,0 +1,120 @@
+package types
+
+import (
+ "bytes"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/rlp"
+)
+
+type CeloDenominatedTx struct {
+ ChainID *big.Int
+ Nonce uint64
+ GasTipCap *big.Int
+ GasFeeCap *big.Int
+ Gas uint64
+ To *common.Address `rlp:"nil"` // nil means contract creation
+ Value *big.Int
+ Data []byte
+ AccessList AccessList
+
+ FeeCurrency *common.Address `rlp:"nil"` // nil means native currency
+ MaxFeeInFeeCurrency *big.Int
+
+ // Signature values
+ V *big.Int `json:"v" gencodec:"required"`
+ R *big.Int `json:"r" gencodec:"required"`
+ S *big.Int `json:"s" gencodec:"required"`
+}
+
+// copy creates a deep copy of the transaction data and initializes all fields.
+func (tx *CeloDenominatedTx) copy() TxData {
+ cpy := &CeloDenominatedTx{
+ Nonce: tx.Nonce,
+ To: copyAddressPtr(tx.To),
+ Data: common.CopyBytes(tx.Data),
+ Gas: tx.Gas,
+ FeeCurrency: copyAddressPtr(tx.FeeCurrency),
+ // These are copied below.
+ AccessList: make(AccessList, len(tx.AccessList)),
+ Value: new(big.Int),
+ ChainID: new(big.Int),
+ GasTipCap: new(big.Int),
+ GasFeeCap: new(big.Int),
+ V: new(big.Int),
+ R: new(big.Int),
+ S: new(big.Int),
+ }
+ if tx.MaxFeeInFeeCurrency != nil {
+ cpy.MaxFeeInFeeCurrency = new(big.Int).Set(tx.MaxFeeInFeeCurrency)
+ }
+ copy(cpy.AccessList, tx.AccessList)
+ if tx.Value != nil {
+ cpy.Value.Set(tx.Value)
+ }
+ if tx.ChainID != nil {
+ cpy.ChainID.Set(tx.ChainID)
+ }
+ if tx.GasTipCap != nil {
+ cpy.GasTipCap.Set(tx.GasTipCap)
+ }
+ if tx.GasFeeCap != nil {
+ cpy.GasFeeCap.Set(tx.GasFeeCap)
+ }
+ if tx.V != nil {
+ cpy.V.Set(tx.V)
+ }
+ if tx.R != nil {
+ cpy.R.Set(tx.R)
+ }
+ if tx.S != nil {
+ cpy.S.Set(tx.S)
+ }
+ return cpy
+}
+
+// accessors for innerTx.
+func (tx *CeloDenominatedTx) txType() byte { return CeloDenominatedTxType }
+func (tx *CeloDenominatedTx) chainID() *big.Int { return tx.ChainID }
+func (tx *CeloDenominatedTx) accessList() AccessList { return tx.AccessList }
+func (tx *CeloDenominatedTx) data() []byte { return tx.Data }
+func (tx *CeloDenominatedTx) gas() uint64 { return tx.Gas }
+func (tx *CeloDenominatedTx) gasFeeCap() *big.Int { return tx.GasFeeCap }
+func (tx *CeloDenominatedTx) gasTipCap() *big.Int { return tx.GasTipCap }
+func (tx *CeloDenominatedTx) gasPrice() *big.Int { return tx.GasFeeCap }
+func (tx *CeloDenominatedTx) value() *big.Int { return tx.Value }
+func (tx *CeloDenominatedTx) nonce() uint64 { return tx.Nonce }
+func (tx *CeloDenominatedTx) to() *common.Address { return tx.To }
+func (tx *CeloDenominatedTx) isSystemTx() bool { return false }
+
+func (tx *CeloDenominatedTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
+ if baseFee == nil {
+ return dst.Set(tx.GasFeeCap)
+ }
+ tip := dst.Sub(tx.GasFeeCap, baseFee)
+ if tip.Cmp(tx.GasTipCap) > 0 {
+ tip.Set(tx.GasTipCap)
+ }
+ return tip.Add(tip, baseFee)
+}
+
+func (tx *CeloDenominatedTx) rawSignatureValues() (v, r, s *big.Int) {
+ return tx.V, tx.R, tx.S
+}
+
+func (tx *CeloDenominatedTx) setSignatureValues(chainID, v, r, s *big.Int) {
+ tx.ChainID, tx.V, tx.R, tx.S = chainID, v, r, s
+}
+
+func (tx *CeloDenominatedTx) encode(b *bytes.Buffer) error {
+ return rlp.Encode(b, tx)
+}
+
+func (tx *CeloDenominatedTx) decode(input []byte) error {
+ return rlp.DecodeBytes(input, tx)
+}
+
+func (tx *CeloDenominatedTx) feeCurrency() *common.Address { return tx.FeeCurrency }
+
+func (tx *CeloDenominatedTx) maxFeeInFeeCurrency() *big.Int { return tx.MaxFeeInFeeCurrency }

core/types/celo_dynamic_fee_tx.go

@@ -114,4 +114,5 @@ func (tx *CeloDynamicFeeTx) decode(input []byte) error {
  return rlp.DecodeBytes(input, tx)
 }
 
-func (tx *CeloDynamicFeeTx) feeCurrency() *common.Address { return tx.FeeCurrency }
+func (tx *CeloDynamicFeeTx) feeCurrency() *common.Address { return tx.FeeCurrency }
+func (tx *CeloDynamicFeeTx) maxFeeInFeeCurrency() *big.Int { return nil }

core/types/celo_transaction_signing.go

@@ -36,7 +36,7 @@ func NewCel2Signer(chainId *big.Int) Signer {
 }
 
 func (s cel2Signer) Sender(tx *Transaction) (common.Address, error) {
- if tx.Type() != CeloDynamicFeeTxType {
+ if tx.Type() != CeloDynamicFeeTxType && tx.Type() != CeloDenominatedTxType {
  return s.londonSigner.Sender(tx)
  }
  V, R, S := tx.RawSignatureValues()
@@ -55,13 +55,14 @@ func (s cel2Signer) Equal(s2 Signer) bool {
 }
 
 func (s cel2Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) {
- txdata, ok := tx.inner.(*CeloDynamicFeeTx)
- if !ok {
+ if tx.Type() != CeloDynamicFeeTxType && tx.Type() != CeloDenominatedTxType {
  return s.londonSigner.SignatureValues(tx, sig)
  }
+
  // 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.chainId) != 0 {
+ chainID := tx.inner.chainID()
+ if chainID.Sign() != 0 && chainID.Cmp(s.chainId) != 0 {
  return nil, nil, nil, ErrInvalidChainId
  }
  R, S, _ = decodeSignature(sig)
@@ -88,5 +89,22 @@ func (s cel2Signer) Hash(tx *Transaction) common.Hash {
  tx.FeeCurrency(),
  })
  }
+ if tx.Type() == CeloDenominatedTxType {
+ return prefixedRlpHash(
+ tx.Type(),
+ []interface{}{
+ s.chainId,
+ tx.Nonce(),
+ tx.GasTipCap(),
+ tx.GasFeeCap(),
+ tx.Gas(),
+ tx.To(),
+ tx.Value(),
+ tx.Data(),
+ tx.AccessList(),
+ tx.FeeCurrency(),
+ tx.MaxFeeInFeeCurrency(),
+ })
+ }
  return s.londonSigner.Hash(tx)
 }

core/types/deposit_tx.go

@@ -102,4 +102,5 @@ func (tx *DepositTx) decode(input []byte) error {
  return rlp.DecodeBytes(input, tx)
 }
 
-func (tx *DepositTx) feeCurrency() *common.Address { return nil }
+func (tx *DepositTx) feeCurrency() *common.Address { return nil }
+func (tx *DepositTx) maxFeeInFeeCurrency() *big.Int { return nil }

core/types/receipt.go

@@ -94,6 +94,9 @@ type Receipt struct {
  // The BaseFee is stored in fee currency for fee currency txs. We need
  // this field to calculate the EffectiveGasPrice for fee currency txs.
  BaseFee *big.Int `json:"baseFee,omitempty"`
+ // The FeeInFeeCurrency is stored in CELO denominated txs. Its value is
+ // exactly what the tx fee was in the FeeCurrency of the tx.
+ FeeInFeeCurrency *big.Int `json:"feeInFeeCurrency,omitempty"`
 }
 
 type receiptMarshaling struct {
@@ -148,6 +151,15 @@ type celoDynamicReceiptRLP struct {
  BaseFee *big.Int
 }
 
+type celoDenominatedReceiptRLP struct {
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Bloom Bloom
+ Logs []*Log
+ // FeeInFeeCurrency was introduced as mandatory in Cel2 ONLY for the CeloDenominatedFeeTxs
+ FeeInFeeCurrency *big.Int
+}
+
 // storedReceiptRLP is the storage encoding of a receipt.
 type storedReceiptRLP struct {
  PostStateOrStatus []byte
@@ -170,6 +182,14 @@ type celoDynamicFeeStoredReceiptRLP struct {
  BaseFee *big.Int
 }
 
+type celoDenominatedStoredReceiptRLP struct {
+ CeloDenominatedReceiptMarker string // Marker to distinguish this from storedReceiptRLP
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Logs []*Log
+ FeeInFeeCurrency *big.Int
+}
+
 // LegacyOptimismStoredReceiptRLP is the pre bedrock storage encoding of a
 // receipt. It will only exist in the database if it was migrated using the
 // migration tool. Nodes that sync using snap-sync will not have any of these
@@ -275,6 +295,9 @@ func (r *Receipt) encodeTyped(data *receiptRLP, w *bytes.Buffer) error {
  case CeloDynamicFeeTxType:
  withBaseFee := &celoDynamicReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.BaseFee}
  return rlp.Encode(w, withBaseFee)
+ case CeloDenominatedTxType:
+ withFeeInFeeCurrency := &celoDenominatedReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.FeeInFeeCurrency}
+ return rlp.Encode(w, withFeeInFeeCurrency)
  case DepositTxType:
  withNonce := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.DepositNonce, r.DepositReceiptVersion}
  return rlp.Encode(w, withNonce)
@@ -365,6 +388,15 @@ func (r *Receipt) decodeTyped(b []byte) error {
  r.Type = b[0]
  r.BaseFee = data.BaseFee
  return r.setFromRLP(receiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs})
+ case CeloDenominatedTxType:
+ var data celoDenominatedReceiptRLP
+ err := rlp.DecodeBytes(b[1:], &data)
+ if err != nil {
+ return err
+ }
+ r.Type = b[0]
+ r.FeeInFeeCurrency = data.FeeInFeeCurrency
+ return r.setFromRLP(receiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs})
  case DepositTxType:
  var data depositReceiptRLP
  err := rlp.DecodeBytes(b[1:], &data)
@@ -434,6 +466,10 @@ func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error {
  listIndex := w.List()
  w.ListEnd(listIndex)
  }
+ if r.Type == CeloDenominatedTxType {
+ // Mark receipt as CeloDenominated receipt by starting with an empty string
+ w.WriteString("")
+ }
  w.WriteBytes((*Receipt)(r).statusEncoding())
  w.WriteUint64(r.CumulativeGasUsed)
  logList := w.List()
@@ -452,6 +488,9 @@ func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error {
  if r.Type == CeloDynamicFeeTxType {
  w.WriteBigInt(r.BaseFee)
  }
+ if r.Type == CeloDenominatedTxType {
+ w.WriteBigInt(r.FeeInFeeCurrency)
+ }
  w.ListEnd(outerList)
  return w.Flush()
 }
@@ -460,12 +499,20 @@ func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error {
 // To distinguish these receipts from the very similar normal receipts, an
 // empty list is added as the first element of the RLP-serialized struct.
 func isCeloDynamicFeeReceipt(blob []byte) bool {
+ return isFirstElementA(blob, 0xc0) // an empty short list
+}
+
+func isCeloDenominatedFeeReceipt(blob []byte) bool {
+ return isFirstElementA(blob, 0x80) // an empty short string
+}
+
+func isFirstElementA(blob []byte, value byte) bool {
  listHeaderSize := 1 // Length of the list header representing the struct in bytes
  if blob[0] > 0xf7 {
  listHeaderSize += int(blob[0]) - 0xf7
  }
  firstListElement := blob[listHeaderSize] // First byte of first list element
- return firstListElement == 0xc0
+ return firstListElement == value
 }
 
 // DecodeRLP implements rlp.Decoder, and loads both consensus and implementation
@@ -480,6 +527,9 @@ func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error {
  if isCeloDynamicFeeReceipt(blob) {
  return decodeStoredCeloDynamicFeeReceiptRLP(r, blob)
  }
+ if isCeloDenominatedFeeReceipt(blob) {
+ return decodeStoredCeloDenominatedReceiptRLP(r, blob)
+ }
  if err := decodeStoredReceiptRLP(r, blob); err == nil {
  return nil
  }
@@ -531,6 +581,21 @@ func decodeStoredCeloDynamicFeeReceiptRLP(r *ReceiptForStorage, blob []byte) err
  return nil
 }
 
+func decodeStoredCeloDenominatedReceiptRLP(r *ReceiptForStorage, blob []byte) error {
+ var stored celoDenominatedStoredReceiptRLP
+ if err := rlp.DecodeBytes(blob, &stored); err != nil {
+ return err
+ }
+ if err := (*Receipt)(r).setStatus(stored.PostStateOrStatus); err != nil {
+ return err
+ }
+ r.CumulativeGasUsed = stored.CumulativeGasUsed
+ r.Logs = stored.Logs
+ r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
+ r.FeeInFeeCurrency = stored.FeeInFeeCurrency
+ return nil
+}
+
 func decodeStoredReceiptRLP(r *ReceiptForStorage, blob []byte) error {
  var stored storedReceiptRLP
  if err := rlp.DecodeBytes(blob, &stored); err != nil {
@@ -573,6 +638,9 @@ func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
  case CeloDynamicFeeTxType:
  celoDynamicData := &celoDynamicReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.BaseFee}
  rlp.Encode(w, celoDynamicData)
+ case CeloDenominatedTxType:
+ celoDenominatedData := &celoDenominatedReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.FeeInFeeCurrency}
+ rlp.Encode(w, celoDenominatedData)
  case DepositTxType:
  if r.DepositReceiptVersion != nil {
  // post-canyon receipt hash computation update