feat(perp): settle markets

x/perp/v2/integration/action/market.go

@@ -16,7 +16,6 @@ import (
 	"github.com/NibiruChain/nibiru/x/perp/v2/types"
 )
 
-// Logger
 type logger struct {
 	log string
 }

x/perp/v2/integration/action/params.go

@@ -4,19 +4,13 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/NibiruChain/nibiru/app"
-	"github.com/NibiruChain/nibiru/x/common/asset"
 	"github.com/NibiruChain/nibiru/x/common/testutil/action"
 )
 
 type changeLiquidationFeeRatio struct {
 	LiquidationFeeRatio sdk.Dec
 }
 
-type setMarketEnabled struct {
-	Enable bool
-	Pair   asset.Pair
-}
-
 func (c changeLiquidationFeeRatio) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
 	// TODO(k-yang): implement
 
@@ -28,20 +22,3 @@ func ChangeLiquidationFeeRatio(liquidationFeeRatio sdk.Dec) action.Action {
 		LiquidationFeeRatio: liquidationFeeRatio,
 	}
 }
-
-// Enable market
-func SetMarketEnabled(pair asset.Pair, enable bool) action.Action {
-	return setMarketEnabled{
-		Enable: enable,
-		Pair:   pair,
-	}
-}
-
-func (c setMarketEnabled) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
-	err := app.PerpKeeperV2.ChangeMarketEnabledParameter(ctx, c.Pair, c.Enable)
-	if err != nil {
-		return ctx, err, true
-	}
-
-	return ctx, nil, true
-}

x/perp/v2/integration/action/position.go

@@ -238,8 +238,32 @@ func ClosePosition(account sdk.AccAddress, pair asset.Pair) action.Action {
 	}
 }
 
-// Manually insert position, skipping open position logic
+type closePositionFailsAction struct {
+	Account sdk.AccAddress
+	Pair    asset.Pair
 
+	expectedErr error
+}
+
+func (c closePositionFailsAction) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
+	_, err := app.PerpKeeperV2.ClosePosition(ctx, c.Pair, c.Account)
+
+	if !errors.Is(err, c.expectedErr) {
+		return ctx, fmt.Errorf("expected error %s, got %s", c.expectedErr, err), true
+	}
+
+	return ctx, nil, true
+}
+
+func ClosePositionFails(account sdk.AccAddress, pair asset.Pair, expectedErr error) action.Action {
+	return &closePositionFailsAction{
+		Account:     account,
+		Pair:        pair,
+		expectedErr: expectedErr,
+	}
+}
+
+// Manually insert position, skipping open position logic
 type insertPosition struct {
 	position types.Position
 }

x/perp/v2/integration/action/settlement.go

@@ -0,0 +1,69 @@
+package action
+
+import (
+	"fmt"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/pkg/errors"
+
+	"github.com/NibiruChain/nibiru/app"
+	"github.com/NibiruChain/nibiru/x/common/asset"
+	"github.com/NibiruChain/nibiru/x/common/testutil/action"
+)
+
+type closeMarket struct {
+	pair asset.Pair
+}
+
+func (c closeMarket) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
+	err := app.PerpKeeperV2.CloseMarket(ctx, c.pair)
+	if err != nil {
+		return ctx, err, false
+	}
+
+	return ctx, nil, true
+}
+
+func CloseMarket(pair asset.Pair) action.Action {
+	return closeMarket{pair: pair}
+}
+
+type settlePosition struct {
+	account sdk.AccAddress
+	pair    asset.Pair
+	version uint64
+}
+
+func (s settlePosition) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
+	err := app.PerpKeeperV2.SettlePosition(ctx, s.account, s.pair, s.version)
+	if err != nil {
+		return ctx, err, false
+	}
+
+	return ctx, nil, true
+}
+
+func SettlePosition(account sdk.AccAddress, pair asset.Pair, version uint64) action.Action {
+	return settlePosition{account: account, pair: pair, version: version}
+}
+
+type settlePositionShouldFail struct {
+	account sdk.AccAddress
+	pair    asset.Pair
+	version uint64
+
+	expectedErr error
+}
+
+func (s settlePositionShouldFail) Do(app *app.NibiruApp, ctx sdk.Context) (sdk.Context, error, bool) {
+	err := app.PerpKeeperV2.SettlePosition(ctx, s.account, s.pair, s.version)
+
+	if !errors.Is(err, s.expectedErr) {
+		return ctx, fmt.Errorf("expected error: %v, got: %v", s.expectedErr, err), false
+	}
+
+	return ctx, nil, true
+}
+
+func SettlePositionShouldFail(account sdk.AccAddress, pair asset.Pair, version uint64, expectedErr error) action.Action {
+	return settlePositionShouldFail{account: account, pair: pair, version: version, expectedErr: expectedErr}
+}

x/perp/v2/keeper/admin_test.go

@@ -11,13 +11,10 @@ import (
 	"github.com/NibiruChain/nibiru/x/common/asset"
 	"github.com/NibiruChain/nibiru/x/common/denoms"
 	"github.com/NibiruChain/nibiru/x/common/testutil"
-	. "github.com/NibiruChain/nibiru/x/common/testutil/action"
 	"github.com/NibiruChain/nibiru/x/common/testutil/mock"
 	"github.com/NibiruChain/nibiru/x/common/testutil/testapp"
-	. "github.com/NibiruChain/nibiru/x/perp/v2/integration/action"
-	. "github.com/NibiruChain/nibiru/x/perp/v2/integration/assertion"
 	"github.com/NibiruChain/nibiru/x/perp/v2/keeper"
-	types "github.com/NibiruChain/nibiru/x/perp/v2/types"
+	"github.com/NibiruChain/nibiru/x/perp/v2/types"
 )
 
 func TestAdmin_WithdrawFromInsuranceFund(t *testing.T) {
@@ -85,28 +82,6 @@ func TestAdmin_WithdrawFromInsuranceFund(t *testing.T) {
 	testutil.RunFunctionTests(t, testCases)
 }
 
-func TestEnableMarket(t *testing.T) {
-	pair := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
-
-	tests := TestCases{
-		TC("true -> false").
-			Given(
-				CreateCustomMarket(pair),
-				MarketShouldBeEqual(pair, Market_EnableShouldBeEqualTo(true)),
-			).
-			When(
-				SetMarketEnabled(pair, false),
-				MarketShouldBeEqual(pair, Market_EnableShouldBeEqualTo(false)),
-				SetMarketEnabled(pair, true),
-			).
-			Then(
-				MarketShouldBeEqual(pair, Market_EnableShouldBeEqualTo(true)),
-			),
-	}
-
-	NewTestSuite(t).WithTestCases(tests...).Run()
-}
-
 func TestCreateMarket(t *testing.T) {
 	pair := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
 	amm := *mock.TestAMMDefault()
@@ -159,8 +134,8 @@ func TestCreateMarket(t *testing.T) {
 	})
 	require.ErrorContains(t, err, "already exists")
 
-	// Disable the market to test that we can create it again but with an increased version
-	err = app.PerpKeeperV2.ChangeMarketEnabledParameter(ctx, pair, false)
+	// Close the market to test that we can create it again but with an increased version
+	err = app.PerpKeeperV2.CloseMarket(ctx, pair)
 	require.NoError(t, err)
 
 	err = app.PerpKeeperV2.Admin().CreateMarket(ctx, keeper.ArgsCreateMarket{

x/perp/v2/keeper/amm.go

@@ -117,7 +117,7 @@ func (k Keeper) handleMarketUpdateCost(ctx sdk.Context, pair asset.Pair, costAmt
 	return nil
 }
 
-// GetMarket returns the market with last version.
+// GetMarket returns the market that is enabled. It is the last version of the market.
 func (k Keeper) GetMarket(ctx sdk.Context, pair asset.Pair) (types.Market, error) {
 	lastVersion, err := k.MarketLastVersion.Get(ctx, pair)
 	if err != nil {
@@ -132,6 +132,16 @@ func (k Keeper) GetMarket(ctx sdk.Context, pair asset.Pair) (types.Market, error
 	return market, nil
 }
 
+// GetMarketByPairAndVersion this function returns the market by pair and version. It can be enabled or disabled.
+func (k Keeper) GetMarketByPairAndVersion(ctx sdk.Context, pair asset.Pair, version uint64) (types.Market, error) {
+	market, err := k.Markets.Get(ctx, collections.Join(pair, version))
+	if err != nil {
+		return types.Market{}, fmt.Errorf("market with pair %s and version %d not found", pair, version)
+	}
+
+	return market, nil
+}
+
 // SaveMarket saves the market by pair and version.
 func (k Keeper) SaveMarket(ctx sdk.Context, market types.Market) {
 	k.Markets.Insert(ctx, collections.Join(market.Pair, market.Version), market)

x/perp/v2/keeper/amm_test.go

@@ -1,6 +1,7 @@
 package keeper_test
 
 import (
+	"fmt"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -416,3 +417,27 @@ func TestEditSwapInvariant(t *testing.T) {
 
 	NewTestSuite(t).WithTestCases(tests...).Run()
 }
+
+func TestKeeper_GetMarketByPairAndVersion(t *testing.T) {
+	app, ctx := testapp.NewNibiruTestAppAndContext()
+
+	pair := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
+
+	err := app.PerpKeeperV2.Admin().CreateMarket(
+		ctx,
+		keeper.ArgsCreateMarket{
+			Pair:            pair,
+			PriceMultiplier: sdk.NewDec(2),
+			SqrtDepth:       sdk.NewDec(1_000_000),
+		},
+	)
+	require.NoError(t, err)
+
+	market, err := app.PerpKeeperV2.Admin().GetMarketByPairAndVersion(ctx, pair, 1)
+	require.NoError(t, err)
+	require.Equal(t, market.Version, uint64(1))
+	require.Equal(t, market.Pair, pair)
+
+	market, err = app.PerpKeeperV2.Admin().GetMarketByPairAndVersion(ctx, pair, 2)
+	require.ErrorContains(t, err, fmt.Sprintf("market with pair %s and version 2 not found", pair.String()))
+}

x/perp/v2/keeper/calc.go

@@ -28,7 +28,7 @@ func PositionNotionalSpot(amm types.AMM, position types.Position) (positionNotio
 	if err != nil {
 		return sdk.Dec{}, err
 	}
-	return amm.FromQuoteReserveToAsset(quoteReserve), nil
+	return amm.QuoteReserveToAsset(quoteReserve), nil
 }
 
 // PositionNotionalTWAP returns the position's notional value based on the TWAP price.

x/perp/v2/keeper/clearing_house.go

@@ -171,7 +171,6 @@ func (k Keeper) increasePosition(
 
 	updatedAMM, baseAssetDeltaAbs, err := k.SwapQuoteAsset(
 		ctx,
-		market,
 		amm,
 		dir,
 		increasedNotional,
@@ -314,7 +313,6 @@ func (k Keeper) decreasePosition(
 
 	updatedAMM, baseAssetDeltaAbs, err := k.SwapQuoteAsset(
 		ctx,
-		market,
 		amm,
 		dir,
 		decreasedNotional,
@@ -446,7 +444,7 @@ func (k Keeper) closeAndOpenReversePosition(
 	}
 
 	// check if it's worth continuing with the increase position
-	quoteReserveAmt := updatedAMM.FromQuoteAssetToReserve(remainingReverseNotionalValue)
+	quoteReserveAmt := updatedAMM.QuoteAssetToReserve(remainingReverseNotionalValue)
 	possibleNextSize, err := updatedAMM.GetBaseReserveAmt(quoteReserveAmt, dir)
 	if err != nil {
 		return nil, nil, err
@@ -703,6 +701,10 @@ func (k Keeper) ClosePosition(ctx sdk.Context, pair asset.Pair, traderAddr sdk.A
 		return nil, fmt.Errorf("%w: %s", types.ErrPairNotFound, pair)
 	}
 
+	if !market.Enabled {
+		return nil, fmt.Errorf("%w: this position can be only closed by Settlement", types.ErrMarketNotEnabled)
+	}
+
 	amm, err := k.GetAMM(ctx, pair)
 	if err != nil {
 		return nil, fmt.Errorf("%w: %s", types.ErrPairNotFound, pair)
@@ -844,6 +846,10 @@ func (k Keeper) PartialClose(
 		return nil, types.ErrPairNotFound.Wrapf("pair: %s", pair)
 	}
 
+	if !market.Enabled {
+		return nil, fmt.Errorf("%w: this position can be only closed by Settlement", types.ErrMarketNotEnabled)
+	}
+
 	amm, err := k.GetAMM(ctx, pair)
 	if err != nil {
 		return nil, types.ErrPairNotFound.Wrapf("pair: %s", pair)
@@ -873,7 +879,7 @@ func (k Keeper) PartialClose(
 	if err != nil {
 		return nil, err
 	}
-	reverseNotionalAmt = amm.FromQuoteReserveToAsset(reverseNotionalAmt)
+	reverseNotionalAmt = amm.QuoteReserveToAsset(reverseNotionalAmt)
 
 	updatedAMM, positionResp, err := k.decreasePosition(ctx, market, amm, position, reverseNotionalAmt, sdk.ZeroDec())
 	if err != nil {

x/perp/v2/keeper/clearing_house_test.go

@@ -873,51 +873,17 @@ func TestMarketOrder(t *testing.T) {
 				PositionShouldNotExist(alice, pairBtcNusd),
 			),
 
-		TC("new long position, can close position after market is not enabled").
-			Given(
-				CreateCustomMarket(pairBtcNusd),
-				SetBlockTime(startBlockTime),
-				SetBlockNumber(1),
-				FundAccount(alice, sdk.NewCoins(sdk.NewCoin(denoms.NUSD, sdk.NewInt(47_714_285_715)))),
-				MarketOrder(alice, pairBtcNusd, types.Direction_SHORT, sdk.NewInt(47_619_047_619), sdk.OneDec(), sdk.ZeroDec()),
-				SetMarketEnabled(pairBtcNusd, false),
-			).
-			When(
-				ClosePosition(alice, pairBtcNusd),
-			).
-			Then(
-				PositionShouldNotExist(alice, pairBtcNusd),
-			),
-
 		TC("new long position, can not open new position after market is not enabled").
 			Given(
 				CreateCustomMarket(pairBtcNusd),
 				SetBlockTime(startBlockTime),
 				SetBlockNumber(1),
 				FundAccount(alice, sdk.NewCoins(sdk.NewCoin(denoms.NUSD, sdk.NewInt(47_714_285_715)))),
-				SetMarketEnabled(pairBtcNusd, false),
-			).
-			When(
-				MarketOrderFails(alice, pairBtcNusd, types.Direction_SHORT, sdk.NewInt(47_619_047_619), sdk.OneDec(), sdk.ZeroDec(),
-					types.ErrMarketNotEnabled),
-			).
-			Then(
-				PositionShouldNotExist(alice, pairBtcNusd),
-			),
-
-		TC("existing long position, can not open new one but can close").
-			Given(
-				CreateCustomMarket(pairBtcNusd),
-				SetBlockTime(startBlockTime),
-				SetBlockNumber(1),
-				FundAccount(alice, sdk.NewCoins(sdk.NewCoin(denoms.NUSD, sdk.NewInt(47_714_285_715)))),
-				MarketOrder(alice, pairBtcNusd, types.Direction_SHORT, sdk.NewInt(50_000), sdk.OneDec(), sdk.ZeroDec()),
-				SetMarketEnabled(pairBtcNusd, false),
+				CloseMarket(pairBtcNusd),
 			).
 			When(
 				MarketOrderFails(alice, pairBtcNusd, types.Direction_SHORT, sdk.NewInt(47_619_047_619), sdk.OneDec(), sdk.ZeroDec(),
 					types.ErrMarketNotEnabled),
-				ClosePosition(alice, pairBtcNusd),
 			).
 			Then(
 				PositionShouldNotExist(alice, pairBtcNusd),