[CLOB-1017] final settlement deleveraging step in PrepareCheckState

protocol/indexer/events/deleveraging.go

@@ -14,15 +14,17 @@ func NewDeleveragingEvent(
 	fillAmount satypes.BaseQuantums,
 	price satypes.BaseQuantums,
 	isBuy bool,
+	isFinalSettlement bool,
 ) *DeleveragingEventV1 {
 	indexerLiquidatedSubaccountId := v1.SubaccountIdToIndexerSubaccountId(liquidatedSubaccountId)
 	indexerOffsettingSubaccountId := v1.SubaccountIdToIndexerSubaccountId(offsettingSubaccountId)
 	return &DeleveragingEventV1{
-		Liquidated:  indexerLiquidatedSubaccountId,
-		Offsetting:  indexerOffsettingSubaccountId,
-		PerpetualId: perpetualId,
-		FillAmount:  fillAmount.ToUint64(),
-		Price:       price.ToUint64(),
-		IsBuy:       isBuy,
+		Liquidated:        indexerLiquidatedSubaccountId,
+		Offsetting:        indexerOffsettingSubaccountId,
+		PerpetualId:       perpetualId,
+		FillAmount:        fillAmount.ToUint64(),
+		Price:             price.ToUint64(),
+		IsBuy:             isBuy,
+		IsFinalSettlement: isFinalSettlement,
 	}
 }

protocol/indexer/events/deleveraging_test.go

@@ -1,9 +1,10 @@
 package events_test
 
 import (
-	satypes "github.com/dydxprotocol/v4-chain/protocol/x/subaccounts/types"
 	"testing"
 
+	satypes "github.com/dydxprotocol/v4-chain/protocol/x/subaccounts/types"
+
 	"github.com/dydxprotocol/v4-chain/protocol/indexer/events"
 	v1 "github.com/dydxprotocol/v4-chain/protocol/indexer/protocol/v1"
 	"github.com/dydxprotocol/v4-chain/protocol/testutil/constants"
@@ -26,6 +27,7 @@ func TestNewDeleveragingEvent_Success(t *testing.T) {
 		fillAmount,
 		price,
 		isBuy,
+		false,
 	)
 	indexerLiquidatedSubaccountId := v1.SubaccountIdToIndexerSubaccountId(liquidatedSubaccountId)
 	indexerOffsettingSubaccountId := v1.SubaccountIdToIndexerSubaccountId(offsettingSubaccountId)

protocol/x/clob/abci.go

@@ -14,6 +14,7 @@ import (
 	"github.com/dydxprotocol/v4-chain/protocol/lib/metrics"
 	"github.com/dydxprotocol/v4-chain/protocol/x/clob/keeper"
 	"github.com/dydxprotocol/v4-chain/protocol/x/clob/types"
+	satypes "github.com/dydxprotocol/v4-chain/protocol/x/subaccounts/types"
 )
 
 // BeginBlocker executes all ABCI BeginBlock logic respective to the clob module.
@@ -198,7 +199,14 @@ func PrepareCheckState(
 
 	// 6. Get all potentially liquidatable subaccount IDs and attempt to liquidate them.
 	subaccountIds := liquidatableSubaccountIds.GetSubaccountIds()
-	if err := keeper.LiquidateSubaccountsAgainstOrderbook(ctx, subaccountIds); err != nil {
+	numDeleveragingAttempts, err := keeper.LiquidateSubaccountsAgainstOrderbook(ctx, subaccountIds)
+	if err != nil {
+		panic(err)
+	}
+
+	// 7. Deleverage subaccounts with open positions in final settlement markets.
+	subaccountOpenPositionInfo := make(map[uint32]map[bool]map[satypes.SubaccountId]struct{})
+	if err := keeper.DeleverageSubaccountsInFinalSettlementMarkets(ctx, subaccountOpenPositionInfo, numDeleveragingAttempts); err != nil {
 		panic(err)
 	}
 

protocol/x/clob/keeper/deleveraging.go

@@ -6,12 +6,11 @@ import (
 	"math/big"
 	"time"
 
-	indexerevents "github.com/dydxprotocol/v4-chain/protocol/indexer/events"
-	"github.com/dydxprotocol/v4-chain/protocol/indexer/indexer_manager"
-
 	errorsmod "cosmossdk.io/errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	indexerevents "github.com/dydxprotocol/v4-chain/protocol/indexer/events"
+	"github.com/dydxprotocol/v4-chain/protocol/indexer/indexer_manager"
 	"github.com/dydxprotocol/v4-chain/protocol/lib"
 	"github.com/dydxprotocol/v4-chain/protocol/lib/metrics"
 	assettypes "github.com/dydxprotocol/v4-chain/protocol/x/assets/types"
@@ -33,13 +32,21 @@ func (k Keeper) MaybeDeleverageSubaccount(
 ) {
 	lib.AssertCheckTxMode(ctx)
 
+	clobPairId, err := k.GetClobPairIdForPerpetual(ctx, perpetualId)
+	if err != nil {
+		return new(big.Int), err
+	}
+	clobPair := k.mustGetClobPair(ctx, clobPairId)
+
 	canPerformDeleveraging, err := k.CanDeleverageSubaccount(ctx, subaccountId)
 	if err != nil {
 		return new(big.Int), err
 	}
 
-	// Early return to skip deleveraging if the subaccount can't be deleveraged.
-	if !canPerformDeleveraging {
+	// Early return to skip deleveraging if the subaccount can't be deleveraged. Make an exception
+	// for markets in final settlement, since final settlement deleveraging is allowed even for
+	// subaccounts with non-negative TNC.
+	if clobPair.Status != types.ClobPair_STATUS_FINAL_SETTLEMENT && !canPerformDeleveraging {
 		metrics.IncrCounter(
 			metrics.ClobPrepareCheckStateCannotDeleverageSubaccount,
 			1,
@@ -229,20 +236,20 @@ func (k Keeper) OffsetSubaccountPerpetualPosition(
 			}
 
 			// TODO(DEC-1495): Determine max amount to offset per offsetting subaccount.
-			var deltaQuantums *big.Int
+			var deltaBaseQuantums *big.Int
 			if deltaQuantumsRemaining.CmpAbs(bigOffsettingPositionQuantums) > 0 {
-				deltaQuantums = new(big.Int).Set(bigOffsettingPositionQuantums)
+				deltaBaseQuantums = new(big.Int).Set(bigOffsettingPositionQuantums)
 			} else {
-				deltaQuantums = new(big.Int).Set(deltaQuantumsRemaining)
+				deltaBaseQuantums = new(big.Int).Set(deltaQuantumsRemaining)
 			}
 
 			// Fetch delta quote quantums. Calculated at bankruptcy price for standard
 			// deleveraging and at oracle price for final settlement deleveraging.
-			deltaQuoteQuantums, err := k.getDeleveragingQuoteQuantumsDelta(
+			deltaQuoteQuantums, isFinalSettlement, err := k.getDeleveragingQuoteQuantumsDelta(
 				ctx,
 				perpetualId,
 				liquidatedSubaccountId,
-				deltaQuantums,
+				deltaBaseQuantums,
 			)
 			if err != nil {
 				liquidatedSubaccount := k.subaccountsKeeper.GetSubaccount(ctx, liquidatedSubaccountId)
@@ -251,9 +258,10 @@ func (k Keeper) OffsetSubaccountPerpetualPosition(
 					"error", err,
 					"blockHeight", ctx.BlockHeight(),
 					"perpetualId", perpetualId,
-					"deltaQuantums", deltaQuantums,
+					"deltaBaseQuantums", deltaBaseQuantums,
 					"liquidatedSubaccount", liquidatedSubaccount,
 					"offsettingSubaccount", offsettingSubaccount,
+					"isFinalSettlement", isFinalSettlement,
 				)
 				return false
 			}
@@ -264,18 +272,37 @@ func (k Keeper) OffsetSubaccountPerpetualPosition(
 				liquidatedSubaccountId,
 				*offsettingSubaccount.Id,
 				perpetualId,
-				deltaQuantums,
+				deltaBaseQuantums,
 				deltaQuoteQuantums,
 			); err == nil {
 				// Update the remaining liquidatable quantums.
 				deltaQuantumsRemaining = new(big.Int).Sub(
 					deltaQuantumsRemaining,
-					deltaQuantums,
+					deltaBaseQuantums,
 				)
 				fills = append(fills, types.MatchPerpetualDeleveraging_Fill{
 					OffsettingSubaccountId: *offsettingSubaccount.Id,
-					FillAmount:             new(big.Int).Abs(deltaQuantums).Uint64(),
+					FillAmount:             new(big.Int).Abs(deltaBaseQuantums).Uint64(),
 				})
+
+				// Send on-chain update for the deleveraging. The events are stored in a TransientStore which should be rolled-back
+				// if the branched state is discarded, so batching is not necessary.
+				k.GetIndexerEventManager().AddTxnEvent(
+					ctx,
+					indexerevents.SubtypeDeleveraging,
+					indexerevents.DeleveragingEventVersion,
+					indexer_manager.GetBytes(
+						indexerevents.NewDeleveragingEvent(
+							liquidatedSubaccountId,
+							*offsettingSubaccount.Id,
+							perpetualId,
+							satypes.BaseQuantums(new(big.Int).Abs(deltaBaseQuantums).Uint64()),
+							satypes.BaseQuantums(deltaQuoteQuantums.Uint64()),
+							deltaBaseQuantums.Sign() > 0,
+							isFinalSettlement,
+						),
+					),
+				)
 			} else if errors.Is(err, types.ErrInvalidPerpetualPositionSizeDelta) {
 				panic(
 					fmt.Sprintf(
@@ -294,12 +321,13 @@ func (k Keeper) OffsetSubaccountPerpetualPosition(
 					"blockHeight", ctx.BlockHeight(),
 					"checkTx", ctx.IsCheckTx(),
 					"perpetualId", perpetualId,
-					"deltaQuantums", deltaQuantums,
+					"deltaQuantums", deltaBaseQuantums,
 					"liquidatedSubaccount", liquidatedSubaccount,
 					"offsettingSubaccount", offsettingSubaccount,
 				)
 				numSubaccountsWithNonOverlappingBankruptcyPrices++
 			}
+
 			return deltaQuantumsRemaining.Sign() == 0
 		},
 		k.GetPseudoRand(ctx),
@@ -338,29 +366,31 @@ func (k Keeper) getDeleveragingQuoteQuantumsDelta(
 	perpetualId uint32,
 	subaccountId satypes.SubaccountId,
 	deltaQuantums *big.Int,
-) (*big.Int, error) {
+) (deltaQuoteQuantums *big.Int, isFinalSettlementDeleverage bool, err error) {
 	clobPair := k.mustGetClobPairForPerpetualId(ctx, perpetualId)
 	isFinalSettlement := clobPair.Status == types.ClobPair_STATUS_FINAL_SETTLEMENT
 
 	// If market is in final settlement and the subaccount has non-negative TNC, use the oracle price.
 	if isFinalSettlement {
 		hasNegativeTnc, err := k.CanDeleverageSubaccount(ctx, subaccountId)
 		if err != nil {
-			return new(big.Int), err
+			return new(big.Int), false, err
 		}
 
 		if !hasNegativeTnc {
-			return k.perpetualsKeeper.GetNetNotional(ctx, perpetualId, deltaQuantums)
+			quantums, err := k.perpetualsKeeper.GetNetNotional(ctx, perpetualId, deltaQuantums)
+			return quantums, true, err
 		}
 	}
 
 	// For standard deleveraging, use the bankruptcy price.
-	return k.GetBankruptcyPriceInQuoteQuantums(
+	quantums, err := k.GetBankruptcyPriceInQuoteQuantums(
 		ctx,
 		subaccountId,
 		perpetualId,
 		deltaQuantums,
 	)
+	return quantums, false, err
 }
 
 // ProcessDeleveraging processes a deleveraging operation by closing both the liquidated subaccount's
@@ -499,23 +529,50 @@ func (k Keeper) ProcessDeleveraging(
 		),
 	)
 
-	// Send on-chain update for the deleveraging. The events are stored in a TransientStore which should be rolled-back
-	// if the branched state is discarded, so batching is not necessary.
-	k.GetIndexerEventManager().AddTxnEvent(
-		ctx,
-		indexerevents.SubtypeDeleveraging,
-		indexerevents.DeleveragingEventVersion,
-		indexer_manager.GetBytes(
-			indexerevents.NewDeleveragingEvent(
-				liquidatedSubaccountId,
-				offsettingSubaccountId,
-				perpetualId,
-				satypes.BaseQuantums(new(big.Int).Abs(deltaBaseQuantums).Uint64()),
-				satypes.BaseQuantums(deltaQuoteQuantums.Uint64()),
-				deltaBaseQuantums.Sign() > 0,
-			),
-		),
-	)
+	return nil
+}
+
+// DeleverageSubaccountsInFinalSettlementMarkets uses the subaccountOpenPositionInfo returned from the
+// liquidations daemon to deleverage subaccounts with open positions in final settlement markets. Note
+// this function will deleverage both negative TNC and non-negative TNC subaccounts. The deleveraging code
+// uses the bankruptcy price for the former and the oracle price for the latter.
+func (k Keeper) DeleverageSubaccountsInFinalSettlementMarkets(
+	ctx sdk.Context,
+	subaccountOpenPositionInfo map[uint32]map[bool]map[satypes.SubaccountId]struct{},
+	numDeleveragingAttempts int,
+) error {
+	// Gather perpetualIds for perpetuals whose clob pairs are in final settlement.
+	finalSettlementPerpetualIds := make(map[uint32]struct{})
+	for _, clobPair := range k.GetAllClobPairs(ctx) {
+		if clobPair.Status == types.ClobPair_STATUS_FINAL_SETTLEMENT {
+			perpetualId := clobPair.MustGetPerpetualId()
+			finalSettlementPerpetualIds[perpetualId] = struct{}{}
+		}
+	}
+
+	// Deleverage subaccounts with open positions in final settlement markets.
+	for perpetualId := range finalSettlementPerpetualIds {
+		for isBuy := range subaccountOpenPositionInfo[perpetualId] {
+			for subaccountId := range subaccountOpenPositionInfo[perpetualId][isBuy] {
+				if numDeleveragingAttempts >= int(k.Flags.MaxDeleveragingAttemptsPerBlock) {
+					return nil
+				}
+
+				if _, err := k.MaybeDeleverageSubaccount(ctx, subaccountId, perpetualId); err != nil {
+					if err != nil {
+						k.Logger(ctx).Error(
+							"DeleverageSubaccountsInFinalSettlementMarkets: Failed to deleverage subaccount.",
+							"subaccount", subaccountId,
+							"perpetualId", perpetualId,
+							"error", err,
+						)
+						return err
+					}
+				}
+				numDeleveragingAttempts++
+			}
+		}
+	}
 
 	return nil
 }

protocol/x/clob/keeper/deleveraging_test.go

@@ -711,6 +711,7 @@ func TestOffsetSubaccountPerpetualPosition(t *testing.T) {
 							satypes.BaseQuantums(fill.FillAmount),
 							satypes.BaseQuantums(bankruptcyPriceQuoteQuantums.Uint64()),
 							tc.deltaQuantums.Sign() > 0,
+							false,
 						),
 					),
 				).Return()
@@ -1126,6 +1127,7 @@ func TestProcessDeleveraging(t *testing.T) {
 							satypes.BaseQuantums(new(big.Int).Abs(tc.deltaQuantums).Uint64()),
 							satypes.BaseQuantums(bankruptcyPriceQuoteQuantums.Uint64()),
 							tc.deltaQuantums.Sign() > 0,
+							false,
 						),
 					),
 				).Return()
@@ -1334,6 +1336,7 @@ func TestProcessDeleveragingAtOraclePrice(t *testing.T) {
 							satypes.BaseQuantums(new(big.Int).Abs(tc.deltaQuantums).Uint64()),
 							satypes.BaseQuantums(fillPriceQuoteQuantums.Uint64()),
 							tc.deltaQuantums.Sign() > 0,
+							false,
 						),
 					),
 				).Return()
@@ -1493,6 +1496,7 @@ func TestProcessDeleveraging_Rounding(t *testing.T) {
 							satypes.BaseQuantums(new(big.Int).Abs(tc.deltaQuantums).Uint64()),
 							satypes.BaseQuantums(bankruptcyPriceQuoteQuantums.Uint64()),
 							tc.deltaQuantums.Sign() > 0,
+							false,
 						),
 					),
 				).Return()