synapsecns/sanguine

package util

import (
    "errors"
    "fmt"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/core"
    "math/big"
)

// CopyTX copies a transaction and sets the nonce to the given value.
// Note: when copying from a dynamic tx to a legacy tx, the chain id cannot be copied over since it's embedded in the signature
// rather than the rlp envelope. Resigning will fix this.
// nolint: cyclop
func CopyTX(unsignedTx *types.Transaction, options ...CopyOption) (*types.Transaction, error) {
    // tx is immutable except within the confines of type. Here we manually copy over the inner values

    // these need to be overwritten, but copied over anyway for parity
    // the v paramater will be modified by the signer if converting from a dynamic tx to a legacy tx
    // in order to add the chain id and correct
    v, r, s := unsignedTx.RawSignatureValues()

    newNonce := unsignedTx.Nonce()
    newGasPrice := unsignedTx.GasPrice()
    newGasFeeCap := unsignedTx.GasFeeCap()
    newGasTipCap := unsignedTx.GasTipCap()
    toChange := makeOptions(options...)
    if toChange.nonce != nil {
        newNonce = *toChange.nonce
    }
    if toChange.gasPrice != nil {
        newGasPrice = toChange.gasPrice
    }
    if toChange.gasFeeCap != nil {
        newGasFeeCap = toChange.gasFeeCap
    }
    if toChange.gasTipCap != nil {
        newGasTipCap = toChange.gasTipCap
    }

    txType := unsignedTx.Type()
    if toChange.txType != nil {
        if txType == types.DynamicFeeTxType && *toChange.txType == types.LegacyTxType {
            // if we're converting from a dynamic fee tx to a legacy tx, we need to resign the tx
            // to fix the return of chainid. This will break the signature, but any modification will
            // see eip-155 (https://eips.ethereum.org/EIPS/eip-155) for details on the signature scheme changes
            var parityBit int

            if v.Uint64() == 28 {
                parityBit++
            }

            mulChainID := new(big.Int).Mul(unsignedTx.ChainId(), big.NewInt(2))
            v = mulChainID.Add(mulChainID, big.NewInt(int64(parityBit+35)))
        }
        txType = *toChange.txType
    }

    switch txType {
    case types.LegacyTxType:
        return types.NewTx(&types.LegacyTx{
            Nonce:    newNonce,
            GasPrice: core.CopyBigInt(newGasPrice),
            Gas:      unsignedTx.Gas(),
            To:       unsignedTx.To(),
            Value:    core.CopyBigInt(unsignedTx.Value()),
            Data:     unsignedTx.Data(),
            V:        core.CopyBigInt(v),
            R:        core.CopyBigInt(r),
            S:        core.CopyBigInt(s),
        }), nil
    case types.AccessListTxType:
        return nil, fmt.Errorf("unsupported tx type %d", types.AccessListTxType)
    case types.DynamicFeeTxType:
        return types.NewTx(&types.DynamicFeeTx{
            ChainID:    core.CopyBigInt(unsignedTx.ChainId()),
            Nonce:      newNonce,
            GasTipCap:  core.CopyBigInt(newGasTipCap),
            GasFeeCap:  core.CopyBigInt(newGasFeeCap),
            Gas:        unsignedTx.Gas(),
            To:         unsignedTx.To(),
            Value:      core.CopyBigInt(unsignedTx.Value()),
            Data:       unsignedTx.Data(),
            AccessList: unsignedTx.AccessList(),
            V:          core.CopyBigInt(v),
            R:          core.CopyBigInt(r),
            S:          core.CopyBigInt(s),
        }), nil
    }
    return nil, errors.New("an unexpected error occurred")
}

// copyOptions is a struct that holds the options for copying a transaction.
type copyOptions struct {
    nonce     *uint64
    gasPrice  *big.Int
    gasFeeCap *big.Int
    gasTipCap *big.Int
    // txType is the type of transaction to copy into
    txType *uint8
}

// CopyOption is a function that sets a copy option
// Certain options are not supported for certain transaction types on purpose
// please exercise caution before adding new options.
type CopyOption func(*copyOptions)

// WithNonce sets the nonce for the copy.
func WithNonce(nonce uint64) CopyOption {
    return func(options *copyOptions) {
        options.nonce = &nonce
    }
}

// WithGasPrice sets the gas price for the copy.
func WithGasPrice(gasPrice *big.Int) CopyOption {
    return func(options *copyOptions) {
        options.gasPrice = gasPrice
    }
}

// WithGasFeeCap sets the gas fee cap for the copy.
func WithGasFeeCap(gasFeeCap *big.Int) CopyOption {
    return func(options *copyOptions) {
        options.gasFeeCap = gasFeeCap
    }
}

// WithGasTipCap sets the gas tip cap for the copy.
func WithGasTipCap(gasTipCap *big.Int) CopyOption {
    return func(options *copyOptions) {
        options.gasTipCap = gasTipCap
    }
}

// WithTxType sets the tx type for the copy.
// should be one of one of types.LegacyTxType, types.AccessListTxType, types.DynamicFeeTxType
// Warning: txtype conversions are not well supported and should be avoided if possible.
func WithTxType(txType uint8) CopyOption {
    return func(options *copyOptions) {
        options.txType = &txType
    }
}

func makeOptions(options ...CopyOption) *copyOptions {
    opts := &copyOptions{}
    for _, option := range options {
        option(opts)
    }
    return opts
}