synapsecns/sanguine

package submitter

import (
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/ethergo/util"
    "go.opentelemetry.io/otel/attribute"
    "math/big"
    "sort"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/synapsecns/sanguine/core"
    "github.com/synapsecns/sanguine/ethergo/chain/gas"
    "github.com/synapsecns/sanguine/ethergo/submitter/db"
)

// copyTransactOpts creates a deep copy of the given TransactOpts struct
// with big ints wrapped in core.CopyBigInt().
func copyTransactOpts(opts *bind.TransactOpts) *bind.TransactOpts {
    copyOpts := &bind.TransactOpts{
        From:      opts.From,
        Nonce:     core.CopyBigInt(opts.Nonce),
        Signer:    opts.Signer,
        Value:     core.CopyBigInt(opts.Value),
        GasPrice:  core.CopyBigInt(opts.GasPrice),
        GasFeeCap: core.CopyBigInt(opts.GasFeeCap),
        GasTipCap: core.CopyBigInt(opts.GasTipCap),
        GasLimit:  opts.GasLimit,
        Context:   opts.Context,
        NoSend:    opts.NoSend,
    }
    return copyOpts
}

func txToAttributes(transaction *types.Transaction, uuid string) (attributes []attribute.KeyValue) {
    attributes = util.TxToAttributes(transaction)
    attributes = append(attributes, attribute.String(uuidAttr, uuid))

    return attributes
}

const uuidAttr = "tx.UUID"

// sortTxesByChainID sorts a slice of transactions by nonce.
func sortTxesByChainID(txs []db.TX, maxPerChain int) map[uint64][]db.TX {
    txesByChainID := make(map[uint64][]db.TX)
    // put the transactions in a map by chain id
    for _, t := range txs {
        txesByChainID[t.ChainId().Uint64()] = append(txesByChainID[t.ChainId().Uint64()], t)
    }

    for key := range txesByChainID {
        key := key // capture range variable
        // sort the transactions by nonce
        sort.Slice(txesByChainID[key], func(i, j int) bool {
            iNonce := txesByChainID[key][i].Nonce()
            jNonce := txesByChainID[key][j].Nonce()

            if iNonce == jNonce {
                gasCmp := gas.CompareGas(txesByChainID[key][i].Transaction, txesByChainID[key][j].Transaction, nil)
                if gasCmp == 0 || gasCmp == 1 {
                    return false
                }
                return true
            }
            return iNonce < jNonce
        })
    }

    // cap the number of txes per chain
    for chainID, txes := range txesByChainID {
        if len(txes) > maxPerChain {
            txesByChainID[chainID] = txes[:maxPerChain]
        }
    }

    return txesByChainID
}

// groupTxesByNonce groups a slice of transactions by nonce.
// this will not differentiate between transactions with different chain ids.
func groupTxesByNonce(txs []db.TX) map[uint64][]db.TX {
    txesByNonce := make(map[uint64][]db.TX)
    for _, t := range txs {
        txesByNonce[t.Nonce()] = append(txesByNonce[t.Nonce()], t)
    }

    return txesByNonce
}

// Function to check if a slice contains a given big integer.
func contains(slice []*big.Int, elem *big.Int) bool {
    for _, v := range slice {
        if v.Cmp(elem) == 0 {
            return true
        }
    }
    return false
}

// Function to get the outersection of two slices of big.Int.
func outersection(set, superset []*big.Int) []*big.Int {
    var result []*big.Int
    for _, elem := range superset {
        if !contains(set, elem) {
            result = append(result, elem)
        }
    }
    return result
}

// Generic function to convert a map[uint64]T to []*big.Int.
func mapToBigIntSlice[T any](m map[uint64]T) []*big.Int {
    var result []*big.Int
    for k := range m {
        bigIntKey := new(big.Int).SetUint64(k)
        result = append(result, bigIntKey)
    }
    return result
}