[CT-1327] place post only orders first in prepare check state

protocol/x/clob/abci.go

@@ -185,15 +185,42 @@ func PrepareCheckState(
 		offchainUpdates,
 	)
 
-	// 3. Place all stateful order placements included in the last block on the memclob.
+	// 3. Go through the orders two times and only place the post only orders during the first pass.
+	longTermOrderIds := keeper.GetDeliveredLongTermOrderIds(ctx)
+	offchainUpdates = keeper.PlaceStatefulOrdersFromLastBlock(
+		ctx,
+		longTermOrderIds,
+		offchainUpdates,
+		true, // post only
+	)
+
+	offchainUpdates = keeper.PlaceConditionalOrdersTriggeredInLastBlock(
+		ctx,
+		processProposerMatchesEvents.ConditionalOrderIdsTriggeredInLastBlock,
+		offchainUpdates,
+		true, // post only
+	)
+
+	replayUpdates := keeper.MemClob.ReplayOperations(
+		ctx,
+		localValidatorOperationsQueue,
+		shortTermOrderTxBytes,
+		offchainUpdates,
+		true, // post only
+	)
+	if replayUpdates != nil {
+		offchainUpdates = replayUpdates
+	}
+
+	// 4. Place all stateful order placements included in the last block on the memclob.
 	// Note telemetry is measured outside of the function call because `PlaceStatefulOrdersFromLastBlock`
 	// is called within `PlaceConditionalOrdersTriggeredInLastBlock`.
 	startPlaceLongTermOrders := time.Now()
-	longTermOrderIds := keeper.GetDeliveredLongTermOrderIds(ctx)
 	offchainUpdates = keeper.PlaceStatefulOrdersFromLastBlock(
 		ctx,
 		longTermOrderIds,
 		offchainUpdates,
+		false, // post only
 	)
 	telemetry.MeasureSince(
 		startPlaceLongTermOrders,
@@ -208,27 +235,27 @@ func PrepareCheckState(
 		metrics.Count,
 	)
 
-	// 4. Place all conditional orders triggered in EndBlocker of last block on the memclob.
+	// 5. Place all conditional orders triggered in EndBlocker of last block on the memclob.
 	offchainUpdates = keeper.PlaceConditionalOrdersTriggeredInLastBlock(
 		ctx,
 		processProposerMatchesEvents.ConditionalOrderIdsTriggeredInLastBlock,
 		offchainUpdates,
+		false, // post only
 	)
 
-	// 5. Replay the local validator’s operations onto the book.
-	replayUpdates := keeper.MemClob.ReplayOperations(
+	// 6. Replay the local validator’s operations onto the book.
+	replayUpdates = keeper.MemClob.ReplayOperations(
 		ctx,
 		localValidatorOperationsQueue,
 		shortTermOrderTxBytes,
 		offchainUpdates,
+		false, // post only
 	)
-
-	// TODO(CLOB-275): Do not gracefully handle panics in `PrepareCheckState`.
 	if replayUpdates != nil {
 		offchainUpdates = replayUpdates
 	}
 
-	// 6. Get all potentially liquidatable subaccount IDs and attempt to liquidate them.
+	// 7. Get all potentially liquidatable subaccount IDs and attempt to liquidate them.
 	liquidatableSubaccountIds := keeper.DaemonLiquidationInfo.GetLiquidatableSubaccountIds()
 	subaccountsToDeleverage, err := keeper.LiquidateSubaccountsAgainstOrderbook(ctx, liquidatableSubaccountIds)
 	if err != nil {
@@ -241,14 +268,14 @@ func PrepareCheckState(
 		keeper.GetSubaccountsWithPositionsInFinalSettlementMarkets(ctx)...,
 	)
 
-	// 7. Deleverage subaccounts.
+	// 8. Deleverage subaccounts.
 	// TODO(CLOB-1052) - decouple steps 6 and 7 by using DaemonLiquidationInfo.NegativeTncSubaccounts
 	// as the input for this function.
 	if err := keeper.DeleverageSubaccounts(ctx, subaccountsToDeleverage); err != nil {
 		panic(err)
 	}
 
-	// 8. Gate withdrawals by inserting a zero-fill deleveraging operation into the operations queue if any
+	// 9. Gate withdrawals by inserting a zero-fill deleveraging operation into the operations queue if any
 	// of the negative TNC subaccounts still have negative TNC after liquidations and deleveraging steps.
 	negativeTncSubaccountIds := keeper.DaemonLiquidationInfo.GetNegativeTncSubaccountIds()
 	if err := keeper.GateWithdrawalsIfNegativeTncSubaccountSeen(ctx, negativeTncSubaccountIds); err != nil {

protocol/x/clob/keeper/orders.go

@@ -496,6 +496,7 @@ func (k Keeper) PlaceStatefulOrdersFromLastBlock(
 	ctx sdk.Context,
 	placedStatefulOrderIds []types.OrderId,
 	existingOffchainUpdates *types.OffchainUpdates,
+	onlyPlacePostOnly bool,
 ) (
 	offchainUpdates *types.OffchainUpdates,
 ) {
@@ -521,6 +522,12 @@ func (k Keeper) PlaceStatefulOrdersFromLastBlock(
 		}
 
 		order := orderPlacement.GetOrder()
+
+		// Prioritize placing post-only orders if the flag is set.
+		if onlyPlacePostOnly && !order.IsPostOnlyOrder() {
+			continue
+		}
+
 		// Validate and place order.
 		_, orderStatus, placeOrderOffchainUpdates, err := k.AddPreexistingStatefulOrder(
 			ctx,
@@ -579,6 +586,7 @@ func (k Keeper) PlaceConditionalOrdersTriggeredInLastBlock(
 	ctx sdk.Context,
 	conditionalOrderIdsTriggeredInLastBlock []types.OrderId,
 	existingOffchainUpdates *types.OffchainUpdates,
+	onlyPlacePostOnly bool,
 ) (
 	offchainUpdates *types.OffchainUpdates,
 ) {
@@ -608,7 +616,12 @@ func (k Keeper) PlaceConditionalOrdersTriggeredInLastBlock(
 		}
 	}
 
-	return k.PlaceStatefulOrdersFromLastBlock(ctx, conditionalOrderIdsTriggeredInLastBlock, existingOffchainUpdates)
+	return k.PlaceStatefulOrdersFromLastBlock(
+		ctx,
+		conditionalOrderIdsTriggeredInLastBlock,
+		existingOffchainUpdates,
+		onlyPlacePostOnly,
+	)
 }
 
 // PerformOrderCancellationStatefulValidation performs stateful validation on an order cancellation.

protocol/x/clob/keeper/orders_test.go

@@ -2218,7 +2218,8 @@ func TestPlaceStatefulOrdersFromLastBlock(t *testing.T) {
 			for _, order := range tc.orders {
 				orderIds = append(orderIds, order.OrderId)
 			}
-			ks.ClobKeeper.PlaceStatefulOrdersFromLastBlock(ctx, orderIds, offchainUpdates)
+			ks.ClobKeeper.PlaceStatefulOrdersFromLastBlock(ctx, orderIds, offchainUpdates, true)
+			ks.ClobKeeper.PlaceStatefulOrdersFromLastBlock(ctx, orderIds, offchainUpdates, false)
 
 			// PlaceStatefulOrdersFromLastBlock utilizes the memclob's PlaceOrder flow, but we
 			// do not want to emit PlaceMessages in offchain events for stateful orders. This assertion
@@ -2376,13 +2377,15 @@ func TestPlaceConditionalOrdersTriggeredInLastBlock(t *testing.T) {
 					t,
 					tc.expectedPanic,
 					func() {
-						ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates)
+						ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates, true)
+						ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates, false)
 					},
 				)
 				return
 			}
 
-			ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates)
+			ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates, true)
+			ks.ClobKeeper.PlaceConditionalOrdersTriggeredInLastBlock(ctx, orderIds, offchainUpdates, false)
 
 			// PlaceStatefulOrdersFromLastBlock utilizes the memclob's PlaceOrder flow, but we
 			// do not want to emit PlaceMessages in offchain events for stateful orders. This assertion

protocol/x/clob/memclob/memclob.go

@@ -879,6 +879,7 @@ func (m *MemClobPriceTimePriority) ReplayOperations(
 	localOperations []types.InternalOperation,
 	shortTermOrderTxBytes map[types.OrderHash][]byte,
 	existingOffchainUpdates *types.OffchainUpdates,
+	onlyPlacePostOnly bool,
 ) *types.OffchainUpdates {
 	lib.AssertCheckTxMode(ctx)
 
@@ -923,6 +924,11 @@ func (m *MemClobPriceTimePriority) ReplayOperations(
 		case *types.InternalOperation_ShortTermOrderPlacement:
 			order := operation.GetShortTermOrderPlacement().Order
 
+			// Skip the order if it is a post-only order and we are only replaying post-only orders.
+			if onlyPlacePostOnly && !order.IsPostOnlyOrder() {
+				continue
+			}
+
 			// Set underlying tx bytes so OperationsToPropose may access it and
 			// store the tx bytes on OperationHashToTxBytes data structure
 			shortTermOrderTxBytes, exists := shortTermOrderTxBytes[order.GetOrderHash()]
@@ -1013,6 +1019,11 @@ func (m *MemClobPriceTimePriority) ReplayOperations(
 				continue
 			}
 
+			// Skip the order if it is a post-only order and we are only replaying post-only orders.
+			if onlyPlacePostOnly && !statefulOrderPlacement.Order.IsPostOnlyOrder() {
+				continue
+			}
+
 			// TODO(DEC-998): Research whether it's fine for two post-only orders to be matched. Currently they are dropped.
 			_, orderStatus, placeOrderOffchainUpdates, err := m.clobKeeper.AddPreexistingStatefulOrder(
 				ctx,
@@ -1066,6 +1077,11 @@ func (m *MemClobPriceTimePriority) ReplayOperations(
 				continue
 			}
 
+			// Skip the order if it is a post-only order and we are only replaying post-only orders.
+			if onlyPlacePostOnly && !statefulOrderPlacement.Order.IsPostOnlyOrder() {
+				continue
+			}
+
 			_, orderStatus, placeOrderOffchainUpdates, err := m.PlaceOrder(
 				ctx,
 				statefulOrderPlacement.Order,

protocol/x/clob/types/memclob.go

@@ -110,6 +110,7 @@ type MemClob interface {
 		localOperations []InternalOperation,
 		shortTermOrderTxBytes map[OrderHash][]byte,
 		existingOffchainUpdates *OffchainUpdates,
+		onlyPlacePostOnly bool,
 	) (offchainUpdates *OffchainUpdates)
 	SetMemclobGauges(
 		ctx sdk.Context,

protocol/x/clob/types/order.go

@@ -180,6 +180,11 @@ func (o *Order) IsConditionalOrder() bool {
 	return o.OrderId.IsConditionalOrder()
 }
 
+// IsPostOnlyOrder returns whether this order is a post only order.
+func (o *Order) IsPostOnlyOrder() bool {
+	return o.GetTimeInForce() == Order_TIME_IN_FORCE_POST_ONLY
+}
+
 // CanTrigger returns if a condition order is eligible to be triggered based on a given
 // subticks value. Function will panic if order is not a conditional order.
 func (o *Order) CanTrigger(subticks Subticks) bool {