synapsecns/sanguine

package gas

import (
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/core"
)

// CompareGas allows for gas comparisons between txes. In the case of an eip-1559 txOpts and a
// non-eip 1559 txOpts the eip-1559 txOpts we follow the mempool logic of setting the gasTipCap and the GasFeeCap to the same value
// legacy txes do not use effectivegastipcap since base fee is not present in non-eip 1559 chains
// This is done because the current mempool logic (https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md)
//
// for non bumps (checking confirmations, etc) a nil gas block can be added which will order by tip (according to geth)
//
// gas block here.
//
//    -1 if x <  y
//     0 if x == y
//    +1 if x >  y
func CompareGas(x *types.Transaction, y *types.Transaction, baseFee *big.Int) int {
    if x.Type() == types.LegacyTxType && y.Type() == types.LegacyTxType {
        return x.GasPrice().Cmp(y.GasPrice())
    }

    if baseFee != nil {
        return x.EffectiveGasTipCmp(y, baseFee)
    }
    return x.EffectiveGasTipCmp(y, nil)
}

// FeeGreaterThan determines if gas for a transaction is greater than threshold. This is used to enforce limits.
// DynamicFeeTxes set gas price to FeeTipCap so this will work for both.
func FeeGreaterThan(tx *types.Transaction, threshold *big.Int) bool {
    return tx.GasPrice().Cmp(threshold) > 0
}

// IsDynamicTx determines if a transaction is dynamic based on the options passed in.
// this follows the same logic as the abi binder in determining what txOpts type to use.
// see: https://github.com/ethereum/go-ethereum/blob/b20bc5c0cae6901209610c5f53f01401b6f7974e/accounts/abi/bind/base.go#L310
func IsDynamicTx(opts *bind.TransactOpts) bool {
    return opts.GasFeeCap != nil
}

// OptsToComparableTx converts transaction options to a transaction. This should be used for comparisons only.
func OptsToComparableTx(opts *bind.TransactOpts) (comparableTx *types.Transaction) {
    if IsDynamicTx(opts) {
        comparableTx = types.NewTx(&types.DynamicFeeTx{
            GasTipCap: core.CopyBigInt(opts.GasTipCap),
            GasFeeCap: core.CopyBigInt(opts.GasFeeCap),
        })
    } else {
        comparableTx = types.NewTx(&types.LegacyTx{
            GasPrice: core.CopyBigInt(opts.GasPrice),
        })
    }
    return comparableTx
}

// BumpGasFees bumps the gas price by percent increase. In the case of legacy txes this bumps the gas price
// in the case of fees, this bumps both the tip and fee cap by percent. If the fee cap exceeds the percent bump
// but the fee cap doesn't and the fee cap is still below the tip cap the new fee cap is used without bumping the tip cap.
func BumpGasFees(opts *bind.TransactOpts, percentIncrease int, baseFee *big.Int, maxPrice *big.Int) {
    if IsDynamicTx(opts) {
        bumpDynamicTxFees(opts, percentIncrease, baseFee, maxPrice)
    } else {
        bumpLegacyTxFees(opts, percentIncrease, maxPrice)
    }
}

// bumpLegacyTxFees bumps a legacy txes fee.
func bumpLegacyTxFees(opts *bind.TransactOpts, percentIncrease int, maxPrice *big.Int) {
    // bump the gas price by percent increase
    newPrice := BumpByPercent(opts.GasPrice, percentIncrease)
    // if the current price exceeds max price skip
    if newPrice.Cmp(maxPrice) > 0 {
        logger.Warnf("gas price %s exceeds max price %s, not bumping", newPrice, maxPrice)
        return
    }
    // otherwise set it
    opts.GasPrice = newPrice
}

// bumpDynamicTxFees bumps a dynamicFeeTx fee.
func bumpDynamicTxFees(opts *bind.TransactOpts, percentIncrease int, baseFee, maxPrice *big.Int) {
    newTipCap := BumpByPercent(opts.GasTipCap, percentIncrease)

    newFeeCap := BumpByPercent(opts.GasFeeCap, percentIncrease)
    if maxPrice.Cmp(newFeeCap) > 0 {
        opts.GasFeeCap = newFeeCap
    } else {
        opts.GasFeeCap = maxPrice
        logger.Warnf("new fee cap %s exceeds max price %s, using max price", newFeeCap, maxPrice)
    }

    // if new fee cap less than tip cap AND base (fee + fee cap) > tip cap
    if newFeeCap.Cmp(newTipCap) > 0 && big.NewInt(0).Sub(newFeeCap, baseFee).Cmp(newTipCap) > 0 {
        opts.GasTipCap = newTipCap
    } else {
        logger.Warnf("new tip cap %s still less than fee cap %s + base fee %s, bumping tip not and not fee", newTipCap, newFeeCap, baseFee)
    }

}

// BumpByPercent bumps a gas price by a percentage.
func BumpByPercent(gasPrice *big.Int, percentIncrease int) *big.Int {
    if gasPrice == nil {
        return nil
    }
    price := core.CopyBigInt(gasPrice)
    calculatedGasPrice := big.NewFloat(0).Mul(big.NewFloat(1+0.01*float64(percentIncrease)), big.NewFloat(0).SetInt(price))
    price, _ = calculatedGasPrice.Int(price)
    return price
}

// min gets the minimum of two big ints.
func min(a, b *big.Int) *big.Int {
    if a.Cmp(b) > 0 {
        return b
    }
    return a
}