fix: ensure we hit leave auction trigger on mark-price calc, and hand…

…le zero length auction intervals in perpetual

core/execution/common/mark_price.go

@@ -281,11 +281,11 @@ func (mpc *CompositePriceCalculator) updateMarkPriceIfNotInAuction(ctx context.C
 		return nil
 	}
 	priceMonitor.CheckPrice(ctx, as, []*types.Trade{{Price: mpcCandidate, Size: 1}}, true, true)
-	if !as.InAuction() {
-		mpc.price = mpcCandidate
-		return nil
+	if as.InAuction() || as.AuctionStart() {
+		return fmt.Errorf("price monitoring failed for the new mark price")
 	}
-	return fmt.Errorf("price monitoring failed for the new mark price")
+	mpc.price = mpcCandidate
+	return nil
 }
 
 // CalculateMarkPrice is called at the end of each mark price calculation interval and calculates the mark price

core/execution/future/market.go

@@ -1580,7 +1580,6 @@ func (m *Market) leaveAuction(ctx context.Context, now time.Time) {
 
 			m.mkt.State = types.MarketStateActive
 			m.mkt.TradingMode = types.MarketTradingModeContinuous
-			m.tradableInstrument.Instrument.UpdateAuctionState(ctx, false)
 			m.broker.Send(events.NewMarketUpdatedEvent(ctx, *m.mkt))
 
 			m.updateLiquidityFee(ctx)
@@ -1612,6 +1611,9 @@ func (m *Market) leaveAuction(ctx context.Context, now time.Time) {
 
 	// update auction state, so we know what the new tradeMode ought to be
 	endEvt := m.as.Left(ctx, now)
+	// we tell the perp that we've left auction, we might re-enter just a bit down but thats fine as
+	// we will at least keep the in/out orders in sync
+	m.tradableInstrument.Instrument.UpdateAuctionState(ctx, false)
 
 	for _, uncrossedOrder := range uncrossedOrders {
 		updatedOrders = append(updatedOrders, uncrossedOrder.Order)

core/products/perpetual.go

@@ -74,7 +74,25 @@ func (a *auctionIntervals) update(t int64, enter bool) {
 	}
 
 	if enter {
-		a.auctionStart = t
+		if len(a.auctions) == 0 {
+			a.auctionStart = t
+			return
+		}
+
+		st, nd := a.auctions[len(a.auctions)-2], a.auctions[len(a.auctions)-1]
+		if t != nd {
+			a.auctionStart = t
+			return
+		}
+
+		a.auctions = slices.Delete(a.auctions, len(a.auctions)-2, len(a.auctions))
+		a.auctionStart = st
+		return
+	}
+
+	if t == a.auctionStart {
+		// left an auction as soon as we entered it, no need to log it
+		a.auctionStart = 0
 		return
 	}
 

core/products/perpetual_auctions_test.go

@@ -235,6 +235,32 @@ func testPastFundingPayment(t *testing.T) {
 	assert.Equal(t, int64(expectedTWAP), fundingPayment.Int64())
 }
 
+func TestZeroLengthAuctionPeriods(t *testing.T) {
+	perp := testPerpetual(t)
+	defer perp.ctrl.Finish()
+
+	// set of the data points such that difference in averages is 0
+	points := getTestDataPoints(t)
+
+	// tell the perpetual that we are ready to accept settlement stuff
+	whenLeaveOpeningAuction(t, perp, points[0].t)
+
+	// enter auction
+	whenAuctionStateChanges(t, perp, points[0].t, true)
+
+	// send in some data points with a TWAP difference
+	submitDataWithDifference(t, perp, points, 10)
+
+	// leave auction
+	whenAuctionStateChanges(t, perp, points[len(points)-1].t, false)
+
+	// but then enter again straight away
+	whenAuctionStateChanges(t, perp, points[len(points)-1].t, true)
+
+	fundingPayment := whenTheFundingPeriodEnds(t, perp, points[len(points)-1].t)
+	assert.Equal(t, "0", fundingPayment.String())
+}
+
 func TestFairgroundPanic(t *testing.T) {
 	perp := testPerpetual(t)
 	defer perp.ctrl.Finish()