fix(pkg/userop): fix gas multiplication (#461)

nksazonov · web-flow · commit ce9dc3331d97 · 2024-12-09T14:17:55.000+02:00
* fix(pkg/userop): fix gas multiplication

* refactor(pkg/userop): extract gas price provider, make mocked one

* test(pkg/userop): skip get polygon gas prices test
diff --git a/pkg/userop/gas.go b/pkg/userop/gas.go
@@ -2,85 +2,28 @@ package userop
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
-	"io"
 	"math/big"
-	"net/http"
 	"strconv"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/shopspring/decimal"
 )
 
-func getPolygonGasPrices(chainId *big.Int) (*big.Int, *big.Int, error) {
-	var resp *http.Response
-	var err error
+func getGasPricesAndApplyMultipliers(ctx context.Context, provider GasPriceProvider, gasConfig GasConfig) (maxFeePerGas, maxPriorityFeePerGas *big.Int, err error) {
+	logger.Debug("getting gas prices")
 
-	if chainId == nil {
-		return nil, nil, fmt.Errorf("chain ID is nil")
-	}
-
-	switch {
-	case chainId.Uint64() == 137:
-		resp, err = http.Get("https://gasstation.polygon.technology/v2")
-	case chainId.Uint64() == 80002:
-		resp, err = http.Get("https://gasstation.polygon.technology/amoy")
-	default:
-		return nil, nil, fmt.Errorf("unsupported chain ID: %v", chainId)
-	}
-
-	if err != nil {
-		return nil, nil, fmt.Errorf("error fetching data: %v", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
+	maxFeePerGas, maxPriorityFeePerGas, err = provider.GetGasPrices(ctx)
 	if err != nil {
-		return nil, nil, fmt.Errorf("error reading response body: %v", err)
-	}
-
-	var gasData struct {
-		Fast struct {
-			MaxPriorityFee decimal.Decimal `json:"maxPriorityFee"`
-			MaxFee         decimal.Decimal `json:"maxFee"`
-		} `json:"fast"`
+		return nil, nil, fmt.Errorf("failed to get gas prices: %w", err)
 	}
 
-	err = json.Unmarshal(body, &gasData)
-	if err != nil {
-		return nil, nil, fmt.Errorf("error unmarshalling JSON: %v", err)
-	}
+	logger.Debug("fetched gas price", "maxFeePerGas", maxFeePerGas, "maxPriorityFeePerGas", maxPriorityFeePerGas)
 
-	gweiMult := decimal.NewFromInt(1e9)
-
-	maxFeePerGas := gasData.Fast.MaxFee.Mul(gweiMult).BigInt()
-	maxPriorityFeePerGas := gasData.Fast.MaxPriorityFee.Mul(gweiMult).BigInt()
-
-	return maxFeePerGas, maxPriorityFeePerGas, nil
-}
-
-func getGasPrices(ctx context.Context, provider EthBackend) (*big.Int, *big.Int, error) {
-	var maxPriorityFeePerGasStr string
-	if err := provider.RPC().CallContext(ctx, &maxPriorityFeePerGasStr, "eth_maxPriorityFeePerGas"); err != nil {
-		return nil, nil, err
-	}
-
-	maxPriorityFeePerGas, ok := new(big.Int).SetString(maxPriorityFeePerGasStr, 0)
-	if !ok {
-		return nil, nil, fmt.Errorf("failed to parse maxPriorityFeePerGas: %s", maxPriorityFeePerGasStr)
-	}
-	logger.Debug("fetched maxPriorityFeePerGas", "maxPriorityFeePerGas", maxPriorityFeePerGas.String())
-
-	// Get the latest block to read its base fee
-	block, err := provider.BlockByNumber(ctx, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-	blockBaseFee := block.BaseFee()
-	logger.Debug("fetched block base fee", "baseFee", blockBaseFee.String())
+	maxFeePerGas = decimal.NewFromBigInt(maxFeePerGas, 0).Mul(gasConfig.MaxFeePerGasMultiplier).BigInt()
+	maxPriorityFeePerGas = decimal.NewFromBigInt(maxPriorityFeePerGas, 0).Mul(gasConfig.MaxPriorityFeePerGasMultiplier).BigInt()
 
-	maxFeePerGas := blockBaseFee.Add(blockBaseFee, maxPriorityFeePerGas)
+	logger.Debug("calculated gas price", "maxFeePerGas", maxFeePerGas, "maxPriorityFeePerGas", maxPriorityFeePerGas)
 
 	return maxFeePerGas, maxPriorityFeePerGas, nil
 }
diff --git a/pkg/userop/gas_price_provider.go b/pkg/userop/gas_price_provider.go
@@ -0,0 +1,116 @@
+package userop
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/big"
+	"net/http"
+
+	"github.com/shopspring/decimal"
+)
+
+type GasPriceProvider interface {
+	GetGasPrices(ctx context.Context) (maxFeePerGas, maxPriorityFeePerGas *big.Int, err error)
+}
+
+type EVMGasPriceProvider struct {
+	provider EthBackend
+}
+
+func NewEVMGasPriceProvider(provider EthBackend) *EVMGasPriceProvider {
+	return &EVMGasPriceProvider{provider: provider}
+}
+
+func (p *EVMGasPriceProvider) GetGasPrices(ctx context.Context) (maxFeePerGas, maxPriorityFeePerGas *big.Int, err error) {
+	var maxPriorityFeePerGasStr string
+	if err := p.provider.RPC().CallContext(ctx, &maxPriorityFeePerGasStr, "eth_maxPriorityFeePerGas"); err != nil {
+		return nil, nil, err
+	}
+
+	maxPriorityFeePerGas, ok := new(big.Int).SetString(maxPriorityFeePerGasStr, 0)
+	if !ok {
+		return nil, nil, fmt.Errorf("failed to parse maxPriorityFeePerGas: %s", maxPriorityFeePerGasStr)
+	}
+	logger.Debug("fetched maxPriorityFeePerGas", "maxPriorityFeePerGas", maxPriorityFeePerGas.String())
+
+	// Get the latest block to read its base fee
+	block, err := p.provider.BlockByNumber(ctx, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	blockBaseFee := block.BaseFee()
+	logger.Debug("fetched block base fee", "baseFee", blockBaseFee.String())
+
+	maxFeePerGas = blockBaseFee.Add(blockBaseFee, maxPriorityFeePerGas)
+
+	return maxFeePerGas, maxPriorityFeePerGas, nil
+}
+
+type PolygonGasPriceProvider struct {
+	chainId *big.Int
+}
+
+func NewPolygonGasPriceProvider(chainId *big.Int) *PolygonGasPriceProvider {
+	return &PolygonGasPriceProvider{chainId: chainId}
+}
+
+func (p *PolygonGasPriceProvider) GetGasPrices(ctx context.Context) (maxFeePerGas, maxPriorityFeePerGas *big.Int, err error) {
+	var resp *http.Response
+
+	if p.chainId == nil {
+		return nil, nil, fmt.Errorf("chain ID is nil")
+	}
+
+	switch {
+	case p.chainId.Uint64() == 137:
+		resp, err = http.Get("https://gasstation.polygon.technology/v2")
+	case p.chainId.Uint64() == 80002:
+		resp, err = http.Get("https://gasstation.polygon.technology/amoy")
+	default:
+		return nil, nil, fmt.Errorf("unsupported chain ID: %v", p.chainId)
+	}
+
+	if err != nil {
+		return nil, nil, fmt.Errorf("error fetching data: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error reading response body: %v", err)
+	}
+
+	var gasData struct {
+		Fast struct {
+			MaxPriorityFee decimal.Decimal `json:"maxPriorityFee"`
+			MaxFee         decimal.Decimal `json:"maxFee"`
+		} `json:"fast"`
+	}
+
+	err = json.Unmarshal(body, &gasData)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error unmarshalling JSON: %v", err)
+	}
+
+	gweiMult := decimal.NewFromInt(1e9)
+
+	maxFeePerGas = gasData.Fast.MaxFee.Mul(gweiMult).BigInt()
+	maxPriorityFeePerGas = gasData.Fast.MaxPriorityFee.Mul(gweiMult).BigInt()
+
+	return maxFeePerGas, maxPriorityFeePerGas, nil
+}
+
+type MockGasPriceProvider struct {
+	maxFeePerGas         *big.Int
+	maxPriorityFeePerGas *big.Int
+}
+
+func NewMockGasPriceProvider(maxFeePerGas, maxPriorityFeePerGas *big.Int) *MockGasPriceProvider {
+	return &MockGasPriceProvider{maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas}
+}
+
+func (p *MockGasPriceProvider) GetGasPrices(ctx context.Context) (maxFeePerGas, maxPriorityFeePerGas *big.Int, err error) {
+	return p.maxFeePerGas, p.maxPriorityFeePerGas, nil
+}
diff --git a/pkg/userop/gas_price_provider_test.go b/pkg/userop/gas_price_provider_test.go
@@ -0,0 +1,56 @@
+package userop
+
+import (
+	"context"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetPolygonGasPrices(t *testing.T) {
+	t.Skip("should not depend on external services in test environment")
+
+	tests := []struct {
+		name    string
+		chainId *big.Int
+		wantErr bool
+	}{
+		{
+			name:    "should return gas prices for Polygon",
+			chainId: big.NewInt(137),
+			wantErr: false,
+		},
+		{
+			name:    "should return gas prices for Amoy",
+			chainId: big.NewInt(80002),
+			wantErr: false,
+		},
+		{
+			name:    "should return error for other chain",
+			chainId: big.NewInt(42),
+			wantErr: true,
+		},
+		{
+			name:    "should return error if chainId is nil",
+			chainId: nil,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			provider := NewPolygonGasPriceProvider(tt.chainId)
+
+			ctx := context.Background()
+			maxFee, maxPriorityFee, err := provider.GetGasPrices(ctx)
+			if tt.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, maxFee)
+				require.NotNil(t, maxPriorityFee)
+			}
+		})
+	}
+}
diff --git a/pkg/userop/gas_test.go b/pkg/userop/gas_test.go
@@ -1,39 +1,71 @@
 package userop
 
 import (
+	"context"
 	"math/big"
 	"testing"
 
+	"github.com/shopspring/decimal"
 	"github.com/stretchr/testify/require"
 )
 
-func TestGetPolygonGasPrices(t *testing.T) {
-	t.Run("Should return gas prices for Polygon", func(t *testing.T) {
-		chainId := big.NewInt(137)
-		maxFee, maxPriorityFee, err := getPolygonGasPrices(chainId)
-		require.NoError(t, err)
-		require.NotNil(t, maxFee)
-		require.NotNil(t, maxPriorityFee)
-		// Gas station states that for Polygon Mainnet the maxPriorityFee is at least 30 Gwei
-		require.True(t, maxPriorityFee.Cmp(big.NewInt(30).Exp(big.NewInt(10), big.NewInt(9), nil)) >= 0)
-	})
+func TestGetGasPricesMiddleware(t *testing.T) {
+	t.Run("gas multipliers are applied correctly", func(t *testing.T) {
+		mockedMaxFeePerGas := big.NewInt(400200400200)
+		mockedMaxPriorityFeePerGas := big.NewInt(42424242)
+		mockedGasPricesProvider := NewMockGasPriceProvider(mockedMaxFeePerGas, mockedMaxPriorityFeePerGas)
 
-	t.Run("Should return gas prices for Amoy", func(t *testing.T) {
-		chainId := big.NewInt(80002)
-		maxFee, maxPriorityFee, err := getPolygonGasPrices(chainId)
-		require.NoError(t, err)
-		require.NotNil(t, maxFee)
-		require.NotNil(t, maxPriorityFee)
-	})
+		tests := []struct {
+			name                     string
+			gasMultipliers           GasConfig
+			wantMaxFeePerGas         *big.Int
+			wantMaxPriorityFeePerGas *big.Int
+		}{
+			{
+				name:                     "no multipliers supplied result in 0 gas prices",
+				gasMultipliers:           GasConfig{},
+				wantMaxFeePerGas:         big.NewInt(0),
+				wantMaxPriorityFeePerGas: big.NewInt(0),
+			},
+			{
+				name: "1 multipliers do not change gas prices",
+				gasMultipliers: GasConfig{
+					MaxPriorityFeePerGasMultiplier: decimal.NewFromFloat(1),
+					MaxFeePerGasMultiplier:         decimal.NewFromFloat(1),
+				},
+				wantMaxFeePerGas:         mockedMaxFeePerGas,
+				wantMaxPriorityFeePerGas: mockedMaxPriorityFeePerGas,
+			},
+			{
+				name: "1.5 multipliers are applied correctly",
+				gasMultipliers: GasConfig{
+					MaxPriorityFeePerGasMultiplier: decimal.NewFromFloat(1.5),
+					MaxFeePerGasMultiplier:         decimal.NewFromFloat(1.5),
+				},
+				wantMaxFeePerGas:         big.NewInt(600300600300),
+				wantMaxPriorityFeePerGas: big.NewInt(63636363),
+			},
+			{
+				name: "2.25 multipliers are applied correctly",
+				gasMultipliers: GasConfig{
+					MaxPriorityFeePerGasMultiplier: decimal.NewFromFloat(2.25),
+					MaxFeePerGasMultiplier:         decimal.NewFromFloat(2.25),
+				},
+				wantMaxFeePerGas:         big.NewInt(900450900450),
+				wantMaxPriorityFeePerGas: big.NewInt(95454544),
+			},
+		}
 
-	t.Run("Should return error for other chain", func(t *testing.T) {
-		chainId := big.NewInt(42)
-		_, _, err := getPolygonGasPrices(chainId)
-		require.Error(t, err)
-	})
+		ctx := context.Background()
+
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				gotMaxFeePerGas, gotMaxPriorityFeePerGas, err := getGasPricesAndApplyMultipliers(ctx, mockedGasPricesProvider, tt.gasMultipliers)
+				require.NoError(t, err)
 
-	t.Run("Should return error if chainId is nil", func(t *testing.T) {
-		_, _, err := getPolygonGasPrices(nil)
-		require.Error(t, err)
+				require.True(t, gotMaxFeePerGas.Cmp(tt.wantMaxFeePerGas) == 0)
+				require.True(t, gotMaxPriorityFeePerGas.Cmp(tt.wantMaxPriorityFeePerGas) == 0)
+			})
+		}
 	})
 }
diff --git a/pkg/userop/middleware.go b/pkg/userop/middleware.go
