Increase separation of orderbooks in the memclob (#1588)

protocol/x/clob/abci_test.go

@@ -666,7 +666,7 @@ func TestEndBlocker_Success(t *testing.T) {
 			err := keepertest.CreateUsdcAsset(ctx, ks.AssetsKeeper)
 			require.NoError(t, err)
 
-			memClob.On("CreateOrderbook", ctx, constants.ClobPair_Btc).Return()
+			memClob.On("CreateOrderbook", constants.ClobPair_Btc).Return()
 
 			// PerpetualMarketCreateEvents are emitted when initializing the genesis state, so we need to mock
 			// the indexer event manager to expect these events.
@@ -700,7 +700,7 @@ func TestEndBlocker_Success(t *testing.T) {
 				constants.ClobPair_Btc.Status,
 			)
 			require.NoError(t, err)
-			memClob.On("CreateOrderbook", ctx, constants.ClobPair_Eth).Return()
+			memClob.On("CreateOrderbook", constants.ClobPair_Eth).Return()
 			// PerpetualMarketCreateEvents are emitted when initializing the genesis state, so we need to mock
 			// the indexer event manager to expect these events.
 			mockIndexerEventManager.On("AddTxnEvent",

protocol/x/clob/e2e/app_test.go

@@ -382,7 +382,6 @@ func TestHydrationInPreBlocker(t *testing.T) {
 
 	// Order should be on the orderbook
 	_, found = tApp.App.ClobKeeper.MemClob.GetOrder(
-		ctx,
 		constants.LongTermOrder_Carl_Num0_Id0_Clob0_Buy1BTC_Price50000_GTBT10.OrderId,
 	)
 	require.True(t, found)
@@ -492,13 +491,11 @@ func TestHydrationWithMatchPreBlocker(t *testing.T) {
 
 	// Make sure orders are not on the orderbook.
 	_, found = tApp.App.ClobKeeper.MemClob.GetOrder(
-		ctx,
 		constants.LongTermOrder_Carl_Num0_Id0_Clob0_Buy1BTC_Price50000_GTBT10.OrderId,
 	)
 	require.False(t, found)
 
 	_, found = tApp.App.ClobKeeper.MemClob.GetOrder(
-		ctx,
 		constants.LongTermOrder_Dave_Num0_Id0_Clob0_Sell1BTC_Price50000_GTBT10.OrderId,
 	)
 	require.False(t, found)

protocol/x/clob/e2e/batch_cancel_test.go

@@ -274,11 +274,11 @@ func TestBatchCancelSingleCancelFunctionality(t *testing.T) {
 
 			// Verify expectations
 			for orderId, shouldHaveOrder := range tc.expectedOrderIdsInMemclob {
-				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 				require.Equal(t, shouldHaveOrder, exists)
 			}
 			for orderId, expectedCancelExpirationBlock := range tc.expectedCancelExpirationsInMemclob {
-				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(ctx, orderId)
+				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(orderId)
 				require.True(t, exists)
 				require.Equal(t, expectedCancelExpirationBlock, cancelExpirationBlock)
 			}
@@ -650,11 +650,11 @@ func TestBatchCancelBatchFunctionality(t *testing.T) {
 
 			// Verify expectations
 			for orderId, shouldHaveOrder := range tc.expectedOrderIdsInMemclob {
-				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 				require.Equal(t, shouldHaveOrder, exists)
 			}
 			for orderId, expectedCancelExpirationBlock := range tc.expectedCancelExpirationsInMemclob {
-				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(ctx, orderId)
+				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(orderId)
 				if expectedCancelExpirationBlock > 0 {
 					require.True(t, exists)
 					require.Equal(t, expectedCancelExpirationBlock, cancelExpirationBlock)

protocol/x/clob/e2e/long_term_orders_test.go

@@ -1428,7 +1428,7 @@ func TestPlaceLongTermOrder(t *testing.T) {
 			}
 
 			// Verify orderbook
-			_, found := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, tc.order.OrderId)
+			_, found := tApp.App.ClobKeeper.MemClob.GetOrder(tc.order.OrderId)
 			require.Equal(t, tc.orderShouldRestOnOrderbook, found)
 
 			// Verify fill amount
@@ -1843,7 +1843,7 @@ func TestRegression_InvalidTimeInForce(t *testing.T) {
 			}
 
 			// Verify orderbook
-			_, found := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, tc.order.OrderId)
+			_, found := tApp.App.ClobKeeper.MemClob.GetOrder(tc.order.OrderId)
 			require.Equal(t, tc.orderShouldRestOnOrderbook, found)
 
 			// Verify fill amount

protocol/x/clob/e2e/reduce_only_orders_test.go

@@ -600,7 +600,7 @@ func TestReduceOnlyOrders(t *testing.T) {
 
 			// Verify expectations.
 			for orderId, exists := range tc.expectedOrderOnMemClob {
-				_, existsOnMemclob := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+				_, existsOnMemclob := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 				require.Equal(t, exists, existsOnMemclob)
 			}
 

protocol/x/clob/e2e/short_term_orders_test.go

@@ -1060,7 +1060,7 @@ func TestShortTermOrderReplacements(t *testing.T) {
 				}
 
 				for orderId, expectations := range block.orderIdsExpectations {
-					order, exists := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+					order, exists := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 					require.Equal(t, expectations.shouldExistOnMemclob, exists)
 					if expectations.shouldExistOnMemclob {
 						require.Equal(t, expectations.expectedOrder, order)
@@ -1267,11 +1267,11 @@ func TestCancelShortTermOrder(t *testing.T) {
 
 			// Verify expectations
 			for orderId, shouldHaveOrder := range tc.expectedOrderIdsInMemclob {
-				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 				require.Equal(t, shouldHaveOrder, exists)
 			}
 			for orderId, expectedCancelExpirationBlock := range tc.expectedCancelExpirationsInMemclob {
-				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(ctx, orderId)
+				cancelExpirationBlock, exists := tApp.App.ClobKeeper.MemClob.GetCancelOrder(orderId)
 				require.True(t, exists)
 				require.Equal(t, expectedCancelExpirationBlock, cancelExpirationBlock)
 			}
@@ -1842,7 +1842,7 @@ func TestShortTermAdvancedOrders(t *testing.T) {
 			}
 
 			for orderId, shouldHaveOrder := range tc.expectedOrderIdsInMemclob {
-				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(ctx, orderId)
+				_, exists := tApp.App.ClobKeeper.MemClob.GetOrder(orderId)
 				require.Equal(t, shouldHaveOrder, exists)
 			}
 

protocol/x/clob/keeper/clob_pair.go

@@ -158,13 +158,13 @@ func (k Keeper) validateClobPair(ctx sdk.Context, clobPair *types.ClobPair) erro
 // maybeCreateOrderbook creates a new orderbook in the memclob.
 func (k Keeper) maybeCreateOrderbook(ctx sdk.Context, clobPair types.ClobPair) {
 	// Create the corresponding orderbook in the memclob.
-	k.MemClob.MaybeCreateOrderbook(ctx, clobPair)
+	k.MemClob.MaybeCreateOrderbook(clobPair)
 }
 
 // createOrderbook creates a new orderbook in the memclob.
 func (k Keeper) createOrderbook(ctx sdk.Context, clobPair types.ClobPair) {
 	// Create the corresponding orderbook in the memclob.
-	k.MemClob.CreateOrderbook(ctx, clobPair)
+	k.MemClob.CreateOrderbook(clobPair)
 }
 
 // createClobPair creates a new `ClobPair` in the store and creates the corresponding orderbook in the memclob.

protocol/x/clob/keeper/deleveraging.go

@@ -261,7 +261,7 @@ func (k Keeper) GateWithdrawalsIfNegativeTncSubaccountSeen(
 		)
 	}
 	perpetualId := subaccount.PerpetualPositions[0].PerpetualId
-	k.MemClob.InsertZeroFillDeleveragingIntoOperationsQueue(ctx, negativeTncSubaccountId, perpetualId)
+	k.MemClob.InsertZeroFillDeleveragingIntoOperationsQueue(negativeTncSubaccountId, perpetualId)
 	metrics.IncrCountMetricWithLabels(
 		types.ModuleName,
 		metrics.SubaccountsNegativeTncSubaccountSeen,

protocol/x/clob/keeper/equity_tier_limit.go

@@ -94,49 +94,6 @@ func (k Keeper) getEquityTierLimitForSubaccount(
 	return equityTierLimit, nil, nil
 }
 
-// Deprecated: Equity tier limits were removed for short term orders.
-// See https://github.com/dydxprotocol/v4-chain/pull/1318.
-//
-// ValidateSubaccountEquityTierLimitForShortTermOrder returns an error if adding the order would exceed the equity
-// tier limit on how many short term open orders a subaccount can have. Short-term fill-or-kill and immediate-or-cancel
-// orders never rest on the book and will always be allowed as they do not apply to the number of open orders that
-// equity tier limits enforce.
-func (k Keeper) ValidateSubaccountEquityTierLimitForShortTermOrder(ctx sdk.Context, order types.Order) error {
-	if order.RequiresImmediateExecution() {
-		return nil
-	}
-
-	equityTierLimits := k.GetEquityTierLimitConfiguration(ctx).ShortTermOrderEquityTiers
-	if len(equityTierLimits) == 0 {
-		return nil
-	}
-
-	equityTierLimit, netCollateral, err := k.getEquityTierLimitForSubaccount(
-		ctx,
-		order.GetSubaccountId(),
-		equityTierLimits,
-	)
-	if err != nil {
-		return err
-	}
-
-	// For short term orders we just count how many orders exist on the memclob.
-	equityTierCount := k.MemClob.CountSubaccountShortTermOrders(ctx, order.GetSubaccountId())
-
-	// Verify that opening this order would not exceed the maximum amount of orders for the equity tier.
-	if lib.MustConvertIntegerToUint32(equityTierCount) >= equityTierLimit.Limit {
-		return errorsmod.Wrapf(
-			types.ErrOrderWouldExceedMaxOpenOrdersEquityTierLimit,
-			"Opening order would exceed equity tier limit of %d. Order count: %d, total net collateral: %+v, order id: %+v",
-			equityTierLimit.Limit,
-			equityTierCount,
-			netCollateral,
-			order.GetOrderId(),
-		)
-	}
-	return nil
-}
-
 // ValidateSubaccountEquityTierLimitForStatefulOrder returns an error if adding the order would exceed the equity
 // tier limit on how many open orders a subaccount can have.
 //