Stage clob pair creation

indexer/packages/v4-protos/src/codegen/dydxprotocol/clob/finalize_block.ts

@@ -0,0 +1,66 @@
+import { ClobPair, ClobPairSDKType } from "./clob_pair";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+
+export interface ClobStagedFinalizeBlockEvent {
+  /** create_clob_pair indicates a new CLOB pair creation. */
+  createClobPair?: ClobPair;
+}
+/**
+ * ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+ * FinalizeBlock.
+ */
+
+export interface ClobStagedFinalizeBlockEventSDKType {
+  /** create_clob_pair indicates a new CLOB pair creation. */
+  create_clob_pair?: ClobPairSDKType;
+}
+
+function createBaseClobStagedFinalizeBlockEvent(): ClobStagedFinalizeBlockEvent {
+  return {
+    createClobPair: undefined
+  };
+}
+
+export const ClobStagedFinalizeBlockEvent = {
+  encode(message: ClobStagedFinalizeBlockEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.createClobPair !== undefined) {
+      ClobPair.encode(message.createClobPair, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ClobStagedFinalizeBlockEvent {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseClobStagedFinalizeBlockEvent();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.createClobPair = ClobPair.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ClobStagedFinalizeBlockEvent>): ClobStagedFinalizeBlockEvent {
+    const message = createBaseClobStagedFinalizeBlockEvent();
+    message.createClobPair = object.createClobPair !== undefined && object.createClobPair !== null ? ClobPair.fromPartial(object.createClobPair) : undefined;
+    return message;
+  }
+
+};

indexer/packages/v4-protos/src/codegen/gogoproto/bundle.ts

@@ -1,3 +1,3 @@
-import * as _128 from "./gogo";
-export const gogoproto = { ..._128
+import * as _129 from "./gogo";
+export const gogoproto = { ..._129
 };

indexer/packages/v4-protos/src/codegen/google/bundle.ts

@@ -1,16 +1,16 @@
-import * as _129 from "./api/annotations";
-import * as _130 from "./api/http";
-import * as _131 from "./protobuf/descriptor";
-import * as _132 from "./protobuf/duration";
-import * as _133 from "./protobuf/timestamp";
-import * as _134 from "./protobuf/any";
+import * as _130 from "./api/annotations";
+import * as _131 from "./api/http";
+import * as _132 from "./protobuf/descriptor";
+import * as _133 from "./protobuf/duration";
+import * as _134 from "./protobuf/timestamp";
+import * as _135 from "./protobuf/any";
 export namespace google {
-  export const api = { ..._129,
-    ..._130
+  export const api = { ..._130,
+    ..._131
   };
-  export const protobuf = { ..._131,
-    ..._132,
+  export const protobuf = { ..._132,
     ..._133,
-    ..._134
+    ..._134,
+    ..._135
   };
 }

proto/dydxprotocol/clob/finalize_block.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+package dydxprotocol.clob;
+
+import "dydxprotocol/clob/clob_pair.proto";
+
+option go_package = "github.com/dydxprotocol/v4-chain/protocol/x/clob/types";
+
+// ClobStagedFinalizeBlockEvent defines a CLOB event staged during
+// FinalizeBlock.
+message ClobStagedFinalizeBlockEvent {
+  // event is the staged event.
+  oneof event {
+    // create_clob_pair indicates a new CLOB pair creation.
+    ClobPair create_clob_pair = 1;
+  }
+}

protocol/testutil/keeper/clob.go

@@ -293,7 +293,7 @@ func CreateTestClobPairs(
 	clobPairs []types.ClobPair,
 ) {
 	for _, clobPair := range clobPairs {
-		_, err := clobKeeper.CreatePerpetualClobPair(
+		_, err := clobKeeper.CreatePerpetualClobPairAndMemStructs(
 			ctx,
 			clobPair.Id,
 			clobPair.MustGetPerpetualId(),
@@ -352,7 +352,7 @@ func CreateNClobPair(
 			),
 		).Return()
 
-		_, err := keeper.CreatePerpetualClobPair(
+		_, err := keeper.CreatePerpetualClobPairAndMemStructs(
 			ctx,
 			items[i].Id,
 			clobtest.MustPerpetualId(items[i]),

protocol/x/clob/abci.go

@@ -51,6 +51,8 @@ func Precommit(
 	ctx sdk.Context,
 	keeper keeper.Keeper,
 ) {
+	keeper.ProcessStagedFinalizeBlockEvents(ctx)
+
 	if streamingManager := keeper.GetFullNodeStreamingManager(); !streamingManager.Enabled() {
 		return
 	}

protocol/x/clob/abci_test.go

@@ -530,7 +530,7 @@ func TestEndBlocker_Success(t *testing.T) {
 					),
 				),
 			).Once().Return()
-			_, err = ks.ClobKeeper.CreatePerpetualClobPair(
+			_, err = ks.ClobKeeper.CreatePerpetualClobPairAndMemStructs(
 				ctx,
 				constants.ClobPair_Btc.Id,
 				clobtest.MustPerpetualId(constants.ClobPair_Btc),
@@ -563,7 +563,7 @@ func TestEndBlocker_Success(t *testing.T) {
 					),
 				),
 			).Once().Return()
-			_, err = ks.ClobKeeper.CreatePerpetualClobPair(
+			_, err = ks.ClobKeeper.CreatePerpetualClobPairAndMemStructs(
 				ctx,
 				constants.ClobPair_Eth.Id,
 				clobtest.MustPerpetualId(constants.ClobPair_Eth),
@@ -1170,7 +1170,7 @@ func TestPrepareCheckState(t *testing.T) {
 
 			// Create all CLOBs.
 			for _, clobPair := range tc.clobs {
-				_, err = ks.ClobKeeper.CreatePerpetualClobPair(
+				_, err = ks.ClobKeeper.CreatePerpetualClobPairAndMemStructs(
 					ctx,
 					clobPair.Id,
 					clobtest.MustPerpetualId(clobPair),

protocol/x/clob/genesis.go

@@ -19,7 +19,7 @@ func InitGenesis(ctx sdk.Context, k *keeper.Keeper, genState types.GenesisState)
 		if err != nil {
 			panic(errorsmod.Wrap(types.ErrInvalidClobPairParameter, err.Error()))
 		}
-		_, err = k.CreatePerpetualClobPair(
+		_, err = k.CreatePerpetualClobPairAndMemStructs(
 			ctx,
 			elem.Id,
 			perpetualId,

protocol/x/clob/keeper/clob_pair.go

@@ -33,6 +33,34 @@ func clobPairKey(
 	return lib.Uint32ToKey(id.ToUint32())
 }
 
+func (k Keeper) CreatePerpetualClobPairAndMemStructs(
+	ctx sdk.Context,
+	clobPairId uint32,
+	perpetualId uint32,
+	stepSizeBaseQuantums satypes.BaseQuantums,
+	quantumConversionExponent int32,
+	subticksPerTick uint32,
+	status types.ClobPair_Status,
+) (types.ClobPair, error) {
+	clobPair, err := k.createPerpetualClobPair(
+		ctx,
+		clobPairId,
+		perpetualId,
+		stepSizeBaseQuantums,
+		quantumConversionExponent,
+		subticksPerTick,
+		status,
+	)
+	if err != nil {
+		return types.ClobPair{}, err
+	}
+
+	k.MemClob.CreateOrderbook(clobPair)
+	k.SetClobPairIdForPerpetual(clobPair)
+
+	return clobPair, nil
+}
+
 // CreatePerpetualClobPair creates a new perpetual CLOB pair in the store.
 // Additionally, it creates an order book matching the ID of the newly created CLOB pair.
 //
@@ -49,6 +77,38 @@ func (k Keeper) CreatePerpetualClobPair(
 	quantumConversionExponent int32,
 	subticksPerTick uint32,
 	status types.ClobPair_Status,
+) (types.ClobPair, error) {
+	clobPair, err := k.createPerpetualClobPair(
+		ctx,
+		clobPairId,
+		perpetualId,
+		stepSizeBaseQuantums,
+		quantumConversionExponent,
+		subticksPerTick,
+		status,
+	)
+	if err != nil {
+		return types.ClobPair{}, err
+	}
+
+	// Don't stage events for the genesis block.
+	if lib.IsDeliverTxMode(ctx) {
+		if err := k.StageNewClobPairSideEffects(ctx, clobPair); err != nil {
+			return clobPair, err
+		}
+	}
+
+	return clobPair, nil
+}
+
+func (k Keeper) createPerpetualClobPair(
+	ctx sdk.Context,
+	clobPairId uint32,
+	perpetualId uint32,
+	stepSizeBaseQuantums satypes.BaseQuantums,
+	quantumConversionExponent int32,
+	subticksPerTick uint32,
+	status types.ClobPair_Status,
 ) (types.ClobPair, error) {
 	clobPair := types.ClobPair{
 		Metadata: &types.ClobPair_PerpetualClobMetadata{
@@ -69,11 +129,36 @@ func (k Keeper) CreatePerpetualClobPair(
 	// Write the `ClobPair` to state.
 	k.SetClobPair(ctx, clobPair)
 
-	err := k.CreateClobPairStructures(ctx, clobPair)
+	perpetualId, err := clobPair.GetPerpetualId()
 	if err != nil {
-		return clobPair, err
+		panic(err)
+	}
+	perpetual, err := k.perpetualsKeeper.GetPerpetual(ctx, perpetualId)
+	if err != nil {
+		return types.ClobPair{}, err
 	}
 
+	k.GetIndexerEventManager().AddTxnEvent(
+		ctx,
+		indexerevents.SubtypePerpetualMarket,
+		indexerevents.PerpetualMarketEventVersion,
+		indexer_manager.GetBytes(
+			indexerevents.NewPerpetualMarketCreateEvent(
+				perpetualId,
+				clobPair.Id,
+				perpetual.Params.Ticker,
+				perpetual.Params.MarketId,
+				clobPair.Status,
+				clobPair.QuantumConversionExponent,
+				perpetual.Params.AtomicResolution,
+				clobPair.SubticksPerTick,
+				clobPair.StepBaseQuantums,
+				perpetual.Params.LiquidityTier,
+				perpetual.Params.MarketType,
+			),
+		),
+	)
+
 	return clobPair, nil
 }
 
@@ -159,51 +244,30 @@ func (k Keeper) maybeCreateOrderbook(ctx sdk.Context, clobPair types.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(clobPair)
+func (k Keeper) ApplySideEffectsForCNewlobPair(
+	ctx sdk.Context,
+	clobPair types.ClobPair,
+) {
+	// TODO throw error if orderbook is not created.
+	k.MemClob.MaybeCreateOrderbook(clobPair)
+	k.SetClobPairIdForPerpetual(clobPair)
 }
 
-// CreateClobPair performs all non stateful operations to create a CLOB pair.
-// These include creating the corresponding orderbook in the memclob, the mapping between
-// the CLOB pair and the perpetual and the indexer event.
-// This function returns an error if a value for the ClobPair's id already exists in state.
-func (k Keeper) CreateClobPairStructures(ctx sdk.Context, clobPair types.ClobPair) error {
-	// Create the corresponding orderbook in the memclob.
-	k.createOrderbook(ctx, clobPair)
+// StageNewClobPairSideEffects stages a ClobPair creation event, so that any in-memory side effects
+// can happen later when the transaction and block is committed.
+// Note the staged event will be processed only if below are both true:
+//   - The current transaction is committed.
+//   - The current block is agreed upon and committed by consensus.
+func (k Keeper) StageNewClobPairSideEffects(ctx sdk.Context, clobPair types.ClobPair) error {
+	lib.AssertDeliverTxMode(ctx)
 
-	// Create the mapping between clob pair and perpetual.
-	k.SetClobPairIdForPerpetual(ctx, clobPair)
-
-	perpetualId, err := clobPair.GetPerpetualId()
-	if err != nil {
-		panic(err)
-	}
-	perpetual, err := k.perpetualsKeeper.GetPerpetual(ctx, perpetualId)
-	if err != nil {
-		return err
-	}
-
-	k.GetIndexerEventManager().AddTxnEvent(
+	k.finalizeBlockEventStager.StageFinalizeBlockEvent(
 		ctx,
-		indexerevents.SubtypePerpetualMarket,
-		indexerevents.PerpetualMarketEventVersion,
-		indexer_manager.GetBytes(
-			indexerevents.NewPerpetualMarketCreateEvent(
-				perpetualId,
-				clobPair.Id,
-				perpetual.Params.Ticker,
-				perpetual.Params.MarketId,
-				clobPair.Status,
-				clobPair.QuantumConversionExponent,
-				perpetual.Params.AtomicResolution,
-				clobPair.SubticksPerTick,
-				clobPair.StepBaseQuantums,
-				perpetual.Params.LiquidityTier,
-				perpetual.Params.MarketType,
-			),
-		),
+		&types.ClobStagedFinalizeBlockEvent{
+			Event: &types.ClobStagedFinalizeBlockEvent_CreateClobPair{
+				CreateClobPair: &clobPair,
+			},
+		},
 	)
 
 	return nil
@@ -234,14 +298,13 @@ func (k Keeper) HydrateClobPairAndPerpetualMapping(ctx sdk.Context) {
 	for _, clobPair := range clobPairs {
 		// Create the corresponding mapping between clob pair and perpetual.
 		k.SetClobPairIdForPerpetual(
-			ctx,
 			clobPair,
 		)
 	}
 }
 
 // SetClobPairIdForPerpetual sets the mapping between clob pair and perpetual.
-func (k Keeper) SetClobPairIdForPerpetual(ctx sdk.Context, clobPair types.ClobPair) {
+func (k Keeper) SetClobPairIdForPerpetual(clobPair types.ClobPair) {
 	// If this `ClobPair` is for a perpetual, add the `clobPairId` to the list of CLOB pair IDs
 	// that facilitate trading of this perpetual.
 	if perpetualClobMetadata := clobPair.GetPerpetualClobMetadata(); perpetualClobMetadata != nil {