Merge pull request #982 from neutron-org/chore/bpa_test

Chore: bpa test

Author: pr0n00gler

app/app.go

@@ -13,6 +13,7 @@ import (
 	v700 "github.com/neutron-org/neutron/v8/app/upgrades/v7.0.0"
 	v800 "github.com/neutron-org/neutron/v8/app/upgrades/v8.0.0"
 	v800_rc0 "github.com/neutron-org/neutron/v8/app/upgrades/v8.0.0-rc0"
+	v810 "github.com/neutron-org/neutron/v8/app/upgrades/v8.1.0"
 	dynamicfeestypes "github.com/neutron-org/neutron/v8/x/dynamicfees/types"
 	stateverifier "github.com/neutron-org/neutron/v8/x/state-verifier"
 	svkeeper "github.com/neutron-org/neutron/v8/x/state-verifier/keeper"
@@ -239,6 +240,7 @@ var (
 		v700.Upgrade,
 		v800_rc0.Upgrade,
 		v800.Upgrade,
+		v810.Upgrade,
 	}
 
 	// DefaultNodeHome default home directories for the application daemon

app/upgrades/v8.1.0/constants.go

@@ -0,0 +1,18 @@
+package v810
+
+import (
+	storetypes "cosmossdk.io/store/types"
+
+	"github.com/neutron-org/neutron/v8/app/upgrades"
+)
+
+const (
+	// UpgradeName defines the on-chain upgrade name.
+	UpgradeName = "v8.1.0"
+)
+
+var Upgrade = upgrades.Upgrade{
+	UpgradeName:          UpgradeName,
+	CreateUpgradeHandler: CreateUpgradeHandler,
+	StoreUpgrades:        storetypes.StoreUpgrades{},
+}

app/upgrades/v8.1.0/upgrades.go

@@ -0,0 +1,35 @@
+package v810
+
+import (
+	"context"
+	"fmt"
+
+	upgradetypes "cosmossdk.io/x/upgrade/types"
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+
+	"github.com/neutron-org/neutron/v8/app/upgrades"
+)
+
+func CreateUpgradeHandler(
+	mm *module.Manager,
+	configurator module.Configurator,
+	keepers *upgrades.UpgradeKeepers,
+	_ upgrades.StoreKeys,
+	cdc codec.Codec,
+) upgradetypes.UpgradeHandler {
+	return func(c context.Context, _ upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
+		ctx := sdk.UnwrapSDKContext(c)
+
+		ctx.Logger().Info("Starting module migrations...")
+
+		vm, err := mm.RunMigrations(ctx, configurator, vm)
+		if err != nil {
+			return vm, err
+		}
+
+		ctx.Logger().Info(fmt.Sprintf("Migration {%s} applied", UpgradeName))
+		return vm, nil
+	}
+}

app/upgrades/v8.1.0/upgrades_test.go

@@ -0,0 +1,37 @@
+package v810_test
+
+import (
+	"testing"
+
+	upgradetypes "cosmossdk.io/x/upgrade/types"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	v810 "github.com/neutron-org/neutron/v8/app/upgrades/v8.1.0"
+	"github.com/neutron-org/neutron/v8/testutil"
+)
+
+type UpgradeTestSuite struct {
+	testutil.IBCConnectionTestSuite
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+	suite.Run(t, new(UpgradeTestSuite))
+}
+
+func (suite *UpgradeTestSuite) SetupTest() {
+	suite.IBCConnectionTestSuite.SetupTest()
+}
+
+func (suite *UpgradeTestSuite) TestUpgrade() {
+	app := suite.GetNeutronZoneApp(suite.ChainA)
+	ctx := suite.ChainA.GetContext().WithChainID("neutron-1")
+	t := suite.T()
+
+	upgrade := upgradetypes.Plan{
+		Name:   v810.UpgradeName,
+		Info:   "some text here",
+		Height: 100,
+	}
+	require.NoError(t, app.UpgradeKeeper.ApplyUpgrade(ctx, upgrade))
+}

x/dex/keeper/deposit.go

@@ -121,7 +121,8 @@ func (k Keeper) ExecuteDeposit(
 		if k.IsPoolBehindEnemyLines(ctx, pairID, tickIndex, fee, depositAmount0, depositAmount1) {
 			err = sdkerrors.Wrapf(types.ErrDepositBehindEnemyLines,
 				"deposit failed at tick %d fee %d", tickIndex, fee)
-			if option.FailTxOnBel {
+			// Always fail entire tx when SwapOnDeposit is enabled or FailTxOnBel is enabled
+			if option.FailTxOnBel || option.SwapOnDeposit {
 				return nil, nil, math_utils.ZeroPrecDec(), math_utils.ZeroPrecDec(), nil, nil, nil, err
 			}
 			failedDeposits = append(failedDeposits, &types.FailedDeposit{DepositIdx: uint64(i), Error: err.Error()}) //nolint:gosec

x/dex/keeper/integration_placelimitorder_test.go

@@ -345,8 +345,8 @@ func (s *DexTestSuite) TestPlaceLimitOrderWithPrice0To1() {
 	s.aliceWithdrawsLimitSell(trancheKey0)
 
 	// THEN alice gets out ~100 TOKENB and bob gets ~10 TOKENA
-	s.assertAliceBalancesInt(sdkmath.ZeroInt(), sdkmath.NewInt(99_999_977))
-	s.assertBobBalancesInt(sdkmath.NewInt(10000000), sdkmath.NewInt(22))
+	s.assertAliceBalancesInt(sdkmath.ZeroInt(), sdkmath.NewInt(99_999_999))
+	s.assertBobBalancesInt(sdkmath.NewInt(9999002), sdkmath.NewInt(0))
 }
 
 func (s *DexTestSuite) TestPlaceLimitOrderWithPrice1To0() {

x/dex/types/errors.go

@@ -37,7 +37,7 @@ var (
 	ErrTickOutsideRange = sdkerrors.Register(
 		ModuleName,
 		1117,
-		"abs(tick) + fee must be < 559,680",
+		"abs(tick) + fee must be < 529,715",
 	)
 	ErrInvalidPoolDenom = sdkerrors.Register(
 		ModuleName,
@@ -202,7 +202,7 @@ var (
 	ErrPriceOutsideRange = sdkerrors.Register(
 		ModuleName,
 		1160,
-		"Invalid price; 0.00000000000000000000000050 < PRICE > 2020125331305056766451886.728",
+		"Invalid price; 0.000000000000000000000000495 < PRICE > 2020125331305056766452345.127500016657360222036663651",
 	)
 	ErrInvalidPriceAndTick = sdkerrors.Register(
 		ModuleName,

x/dex/types/price.go

@@ -11,12 +11,12 @@ import (
 )
 
 const (
-	// NOTE: 559_680 is the highest possible tick at which price can be calculated with a < 1% error
+	// NOTE: 529_715 is the highest possible tick at which price can be calculated with a < 1% error and all prices are unique for negative ticks
 	// when using 27 digit decimal precision (via prec_dec).
 	// The error rate for very negative ticks approaches zero, so there is no concern there
-	MaxTickExp uint64 = 559_680
-	MinPrice   string = "0.000000000000000000000000495"
-	MaxPrice   string = "2020125331305056766452345.127500016657360222036663651"
+	MaxTickExp uint64 = 529_715
+	MinPrice   string = "0.000000000000000000000009906"
+	MaxPrice   string = "100943872917137109121294.116592697013542139739189686"
 )
 
 //go:embed precomputed_prices.gob
@@ -72,19 +72,25 @@ func BinarySearchPriceToTick(price math_utils.PrecDec) uint64 {
 	right := MaxTickExp
 
 	// Binary search to find the closest precomputed value
+BinarySearch:
 	for left < right {
 		switch mid := (left + right) / 2; {
 		case PrecomputedPrices[mid].Equal(price):
 			return mid
+		case right-left == 1:
+			// Use bottom logic
+			break BinarySearch
 		case PrecomputedPrices[mid].LT(price):
 			left = mid + 1
 		default:
 			right = mid - 1
 
 		}
 	}
-
-	// If exact match is not found, return the upper bound
+	// Round to the nearest tick or exact match
+	if PrecomputedPrices[left].Sub(price).Abs().LT(PrecomputedPrices[right].Sub(price).Abs()) {
+		return left
+	}
 	return right
 }
 

x/dex/types/price_test.go

@@ -1,18 +1,19 @@
 package types_test
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	math_utils "github.com/neutron-org/neutron/v8/utils/math"
 	"github.com/neutron-org/neutron/v8/x/dex/types"
 )
 
 func TestCalcTickIndexFromPrice(t *testing.T) {
 	for _, tc := range []struct {
 		desc string
 		tick int64
+		err  bool
 	}{
 		{
 			desc: "0",
@@ -31,16 +32,16 @@ func TestCalcTickIndexFromPrice(t *testing.T) {
 			tick: 100000,
 		},
 		{
-			desc: "-100000",
-			tick: -100000,
+			desc: "-100051",
+			tick: -100051,
 		},
 		{
-			desc: "-100000",
-			tick: -100000,
+			desc: "-200100",
+			tick: -2000100,
 		},
 		{
-			desc: "-100000",
-			tick: -100000,
+			desc: "400000",
+			tick: 400000,
 		},
 		{
 			desc: "MaxTickExp",
@@ -53,23 +54,37 @@ func TestCalcTickIndexFromPrice(t *testing.T) {
 		{
 			desc: "GT MaxTickExp",
 			tick: int64(types.MaxTickExp) + 1,
+			err:  true,
 		},
 		{
 			desc: "LT MinTickExp",
 			tick: -1*int64(types.MaxTickExp) - 1,
+			err:  true,
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
 			price, err1 := types.CalcPrice(tc.tick)
 			val, err2 := types.CalcTickIndexFromPrice(price)
-			if errors.Is(err1, types.ErrTickOutsideRange) {
-				require.ErrorIs(t, err2, types.ErrPriceOutsideRange)
+			if err1 != nil {
+				require.Error(t, err1)
+				require.Error(t, err2)
 			} else {
-				// Only expected error is ErrTickOutsideRange.
 				// If we are not outside the tick range we should TestCalcTickIndexFromPrice to never throw
+				require.NoError(t, err1)
 				require.NoError(t, err2)
 				require.Equal(t, tc.tick, val)
 			}
 		})
 	}
 }
+func TestPriceDups(t *testing.T) {
+	prevPrice := math_utils.ZeroPrecDec()
+	for i := 0; i >= int(types.MaxTickExp)*-1; i-- {
+		price, err := types.CalcPrice(int64(i))
+		require.NoError(t, err)
+		if price.Equal(prevPrice) {
+			t.Fatalf("Price (%v) %s is equal to previous price %s", i, price, prevPrice)
+		}
+		prevPrice = price
+	}
+}