diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea6f5f034e..0c3c3bd6a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,14 @@
 - [](https://github.com/vegaprotocol/vega/issues/xxx)
 
 
+## 0.77.4
+
+### 🐛 Fixes
+
+- [11508](https://github.com/vegaprotocol/vega/issues/11508) - Handle market order for margin spam protection.
+- [11507](https://github.com/vegaprotocol/vega/issues/11507) - Margin spam check to remove division by asset quantum.
+
+
 ## 0.77.3
 
 ### 🚨 Breaking changes
@@ -57,6 +65,7 @@
 
 - [11481](https://github.com/vegaprotocol/vega/issues/11481) - Fix margin check for cross margin market orders.
 - [11474](https://github.com/vegaprotocol/vega/issues/11474) - Fail `checkTx` downstream for delayed transactions so they don't get included in more than one block.
+- [11506](https://github.com/vegaprotocol/vega/issues/11506) - Fix margin spam check to remove division by asset quantum.
 
 ## 0.77.1
 
diff --git a/core/execution/future/market.go b/core/execution/future/market.go
index eb65c809e7..663b89b106 100644
--- a/core/execution/future/market.go
+++ b/core/execution/future/market.go
@@ -1507,21 +1507,24 @@ func (m *Market) EnterLongBlockAuction(ctx context.Context, duration int64) {
 		return
 	}
 
-	m.mkt.State = types.MarketStateSuspended
-	m.mkt.TradingMode = types.MarketTradingModelLongBlockAuction
 	if m.as.InAuction() {
-		effDuration := int(m.timeService.GetTimeNow().UnixNano()/1e9) + int(duration) - int(m.as.ExpiresAt().UnixNano()/1e9)
-		if effDuration <= 0 {
+		// auction remaining:
+		now := m.timeService.GetTimeNow()
+		aRemaining := int64(m.as.ExpiresAt().Sub(now) / time.Second)
+		if aRemaining >= duration {
 			return
 		}
-		m.as.ExtendAuctionLongBlock(types.AuctionDuration{Duration: int64(effDuration)})
-		evt := m.as.AuctionExtended(ctx, m.timeService.GetTimeNow())
-		if evt != nil {
+		m.as.ExtendAuctionLongBlock(types.AuctionDuration{
+			Duration: duration - aRemaining,
+		})
+		if evt := m.as.AuctionExtended(ctx, now); evt != nil {
 			m.broker.Send(evt)
 		}
 	} else {
 		m.as.StartLongBlockAuction(m.timeService.GetTimeNow(), duration)
 		m.tradableInstrument.Instrument.UpdateAuctionState(ctx, true)
+		m.mkt.TradingMode = types.MarketTradingModelLongBlockAuction
+		m.mkt.State = types.MarketStateSuspended
 		m.enterAuction(ctx)
 		m.broker.Send(events.NewMarketUpdatedEvent(ctx, *m.mkt))
 	}
@@ -1707,6 +1710,7 @@ func (m *Market) leaveAuction(ctx context.Context, now time.Time) {
 			}
 
 			m.mkt.State = types.MarketStateActive
+			// this probably should get the default trading mode from the market definition.
 			m.mkt.TradingMode = types.MarketTradingModeContinuous
 			m.broker.Send(events.NewMarketUpdatedEvent(ctx, *m.mkt))
 
@@ -5324,16 +5328,20 @@ func (m *Market) CheckOrderSubmissionForSpam(orderSubmission *types.OrderSubmiss
 	}
 
 	var price *num.Uint
-	if orderSubmission.PeggedOrder == nil {
-		price, _ = num.UintFromDecimal(orderSubmission.Price.ToDecimal().Mul(m.priceFactor))
-	} else {
+	if orderSubmission.PeggedOrder != nil || orderSubmission.Type == vega.Order_TYPE_MARKET {
 		priceInMarket, _ := num.UintFromDecimal(m.getCurrentMarkPrice().ToDecimal().Div(m.priceFactor))
+		offset := num.UintZero()
+		if orderSubmission.PeggedOrder != nil {
+			offset = orderSubmission.PeggedOrder.Offset
+		}
 		if orderSubmission.Side == types.SideBuy {
-			priceInMarket.AddSum(orderSubmission.PeggedOrder.Offset)
+			priceInMarket.AddSum(offset)
 		} else {
-			priceInMarket = priceInMarket.Sub(priceInMarket, orderSubmission.PeggedOrder.Offset)
+			priceInMarket = priceInMarket.Sub(priceInMarket, offset)
 		}
 		price, _ = num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
+	} else {
+		price, _ = num.UintFromDecimal(orderSubmission.Price.ToDecimal().Mul(m.priceFactor))
 	}
 
 	margins := num.UintZero().Mul(price, num.NewUint(orderSubmission.Size)).ToDecimal().Div(m.positionFactor)
@@ -5342,7 +5350,7 @@ func (m *Market) CheckOrderSubmissionForSpam(orderSubmission *types.OrderSubmiss
 	if err != nil {
 		return err
 	}
-	if margins.Mul(rf.Add(factor)).Div(assetQuantum).LessThan(quantumMultiplier.Mul(assetQuantum)) {
+	if margins.Mul(rf.Add(factor)).LessThan(quantumMultiplier.Mul(assetQuantum)) {
 		return fmt.Errorf("order value is less than minimum maintenance margin for spam")
 	}
 	return nil
diff --git a/core/execution/spot/market.go b/core/execution/spot/market.go
index 602c8ea07b..8fdcb2a820 100644
--- a/core/execution/spot/market.go
+++ b/core/execution/spot/market.go
@@ -497,20 +497,22 @@ func (m *Market) EnterLongBlockAuction(ctx context.Context, duration int64) {
 		return
 	}
 
-	m.mkt.State = types.MarketStateSuspended
-	m.mkt.TradingMode = types.MarketTradingModelLongBlockAuction
 	if m.as.InAuction() {
-		effDuration := int(m.timeService.GetTimeNow().UnixNano()/1e9) + int(duration) - int(m.as.ExpiresAt().UnixNano()/1e9)
-		if effDuration <= 0 {
+		now := m.timeService.GetTimeNow()
+		aRemaining := int64(m.as.ExpiresAt().Sub(now) / time.Second)
+		if aRemaining >= duration {
 			return
 		}
-		m.as.ExtendAuctionLongBlock(types.AuctionDuration{Duration: int64(effDuration)})
-		evt := m.as.AuctionExtended(ctx, m.timeService.GetTimeNow())
-		if evt != nil {
+		m.as.ExtendAuctionLongBlock(types.AuctionDuration{
+			Duration: duration - aRemaining,
+		})
+		if evt := m.as.AuctionExtended(ctx, now); evt != nil {
 			m.broker.Send(evt)
 		}
 	} else {
 		m.as.StartLongBlockAuction(m.timeService.GetTimeNow(), duration)
+		m.mkt.TradingMode = types.MarketTradingModelLongBlockAuction
+		m.mkt.State = types.MarketStateSuspended
 		m.enterAuction(ctx)
 		m.broker.Send(events.NewMarketUpdatedEvent(ctx, *m.mkt))
 	}
@@ -3356,21 +3358,25 @@ func (m *Market) CheckOrderSubmissionForSpam(orderSubmission *types.OrderSubmiss
 	}
 
 	var price *num.Uint
-	if orderSubmission.PeggedOrder == nil {
-		price, _ = num.UintFromDecimal(orderSubmission.Price.ToDecimal().Mul(m.priceFactor))
-	} else {
+	if orderSubmission.PeggedOrder != nil || orderSubmission.Type == vega.Order_TYPE_MARKET {
 		priceInMarket, _ := num.UintFromDecimal(m.getCurrentMarkPrice().ToDecimal().Div(m.priceFactor))
+		offset := num.UintZero()
+		if orderSubmission.PeggedOrder != nil {
+			offset = orderSubmission.PeggedOrder.Offset
+		}
 		if orderSubmission.Side == types.SideBuy {
-			priceInMarket.AddSum(orderSubmission.PeggedOrder.Offset)
+			priceInMarket.AddSum(offset)
 		} else {
-			priceInMarket = priceInMarket.Sub(priceInMarket, orderSubmission.PeggedOrder.Offset)
+			priceInMarket = priceInMarket.Sub(priceInMarket, offset)
 		}
 		price, _ = num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
+	} else {
+		price, _ = num.UintFromDecimal(orderSubmission.Price.ToDecimal().Mul(m.priceFactor))
 	}
 
 	minQuantum := assetQuantum.Mul(quantumMultiplier)
 	value := num.UintZero().Mul(num.NewUint(orderSubmission.Size), price).ToDecimal()
-	value = value.Div(m.positionFactor).Div(assetQuantum)
+	value = value.Div(m.positionFactor)
 	if value.LessThan(minQuantum.Mul(assetQuantum)) {
 		return fmt.Errorf("order value is less than minimum holding requirement for spam")
 	}
diff --git a/core/integration/features/auctions/0094-PRAC-008.feature b/core/integration/features/auctions/0094-PRAC-008.feature
index ffe4efa4e6..239d6c15d9 100644
--- a/core/integration/features/auctions/0094-PRAC-008.feature
+++ b/core/integration/features/auctions/0094-PRAC-008.feature
@@ -131,20 +131,27 @@ Feature: When a market's trigger and extension_trigger are set to represent that
       | 1000000    | TRADING_MODE_MONITORING_AUCTION | 2810994378   | 1873996252     | 1             | 602         | AUCTION_TRIGGER_LONG_BLOCK |
 
     # move ahead another minute
-    When the network moves ahead "60" blocks
+    When the network moves ahead "1" blocks
     # This is strange, it looks as though the trade went through at the end of the auction, but in doing so triggered a second auction?
     Then the market data for the market "ETH/DEC20" should be:
       | mark price | trading mode                    | target stake | supplied stake | open interest | extension trigger          |
       | 1000000    | TRADING_MODE_MONITORING_AUCTION | 2810994378   | 1873996252     | 1             | AUCTION_TRIGGER_LONG_BLOCK |
 
-    When the network moves ahead "8m50s" with block duration of "2s"
+    When the network moves ahead "9m50s" with block duration of "2s"
     Then the trading mode should be "TRADING_MODE_MONITORING_AUCTION" for the market "ETH/DEC20"
     And the trading mode should be "TRADING_MODE_LONG_BLOCK_AUCTION" for the market "ETH/DEC19"
 
     # still in auction, but if we move ahead...
-    When the network moves ahead "150" blocks
-    And the trading mode should be "TRADING_MODE_CONTINUOUS" for the market "ETH/DEC19"
-    Then the trading mode should be "TRADING_MODE_CONTINUOUS" for the market "ETH/DEC20"
+    When the network moves ahead "11" blocks
+    Then the trading mode should be "TRADING_MODE_CONTINUOUS" for the market "ETH/DEC19"
+    And the trading mode should be "TRADING_MODE_MONITORING_AUCTION" for the market "ETH/DEC20"
+    # now move further ahead to leave price auction
+    # We have moved 1 blocks + 9m50s (9m51) + 11 blocks for a total of 10m2s, the total auction duration
+    # was 602s, or 10m2s. Leaving the auction will trigger an extension of another 61 seconds
+    # So the total time in auction would be 11m2s. At this point we're still 61s short.
+    When the network moves ahead "61" blocks
+    Then the trading mode should be "TRADING_MODE_CONTINUOUS" for the market "ETH/DEC19"
+    And the trading mode should be "TRADING_MODE_CONTINUOUS" for the market "ETH/DEC20"
     And the following trades should be executed:
       | buyer  | price  | size | seller |
       | party5 | 999998 | 1    | party6 |
diff --git a/datanode/service/market_depth.go b/datanode/service/market_depth.go
index 34d53c3c0f..264f8d854e 100644
--- a/datanode/service/market_depth.go
+++ b/datanode/service/market_depth.go
@@ -49,6 +49,62 @@ type ammCache struct {
 	ammOrders      map[string][]*types.Order   // map amm id -> expanded orders, so we can remove them if amended
 	activeAMMs     map[string]entities.AMMPool // map amm id -> amm definition, so we can refresh its expansion
 	estimatedOrder map[string]struct{}         // order-id -> whether it was an estimated order
+
+	// the lowest/highest bounds of all AMMs
+	lowestBound  num.Decimal
+	highestBound num.Decimal
+
+	// reference -> calculation levels, if the reference point hasn't changed we can avoid the busy task
+	// of recalculating them
+	levels map[string][]*level
+}
+
+func (c *ammCache) addAMM(a entities.AMMPool) {
+	c.activeAMMs[a.AmmPartyID.String()] = a
+
+	low := a.ParametersBase
+	if a.ParametersLowerBound != nil {
+		low = *a.ParametersLowerBound
+	}
+
+	if c.lowestBound.IsZero() {
+		c.lowestBound = low
+	} else {
+		c.lowestBound = num.MinD(c.lowestBound, low)
+	}
+
+	high := a.ParametersBase
+	if a.ParametersUpperBound != nil {
+		high = *a.ParametersUpperBound
+	}
+	c.highestBound = num.MaxD(c.highestBound, high)
+}
+
+func (c *ammCache) removeAMM(ammParty string) {
+	delete(c.activeAMMs, ammParty)
+	delete(c.ammOrders, ammParty)
+
+	// now we need to recalculate the lowest/highest
+
+	c.lowestBound = num.DecimalZero()
+	c.highestBound = num.DecimalZero()
+	for _, a := range c.activeAMMs {
+		low := a.ParametersBase
+		if a.ParametersLowerBound != nil {
+			low = *a.ParametersLowerBound
+		}
+		if c.lowestBound.IsZero() {
+			c.lowestBound = low
+		} else {
+			c.lowestBound = num.MinD(c.lowestBound, low)
+		}
+
+		high := a.ParametersBase
+		if a.ParametersUpperBound != nil {
+			high = *a.ParametersUpperBound
+		}
+		c.lowestBound = num.MaxD(c.highestBound, high)
+	}
 }
 
 type MarketDepth struct {
diff --git a/datanode/service/market_depth_amm.go b/datanode/service/market_depth_amm.go
index 949f696fec..5d0340f91a 100644
--- a/datanode/service/market_depth_amm.go
+++ b/datanode/service/market_depth_amm.go
@@ -108,7 +108,14 @@ func (m *MarketDepth) getActiveAMMs(ctx context.Context) map[string][]entities.A
 	return ammByMarket
 }
 
-func (m *MarketDepth) getCalculationBounds(reference num.Decimal, priceFactor num.Decimal) []*level {
+func (m *MarketDepth) getCalculationBounds(cache *ammCache, reference num.Decimal, priceFactor num.Decimal) []*level {
+	if levels, ok := cache.levels[reference.String()]; ok {
+		return levels
+	}
+
+	lowestBound := cache.lowestBound
+	highestBound := cache.highestBound
+
 	// first lets calculate the region we will expand accurately, this will be some percentage either side of the reference price
 	factor := num.DecimalFromFloat(m.cfg.AmmFullExpansionPercentage).Div(hundred)
 
@@ -138,6 +145,34 @@ func (m *MarketDepth) getCalculationBounds(reference num.Decimal, priceFactor nu
 	estLow := num.UintZero().Sub(accLow, num.Min(accLow, eRange))
 	estHigh := num.UintZero().Add(accHigh, eRange)
 
+	// cap steps to the lowest/highest boundaries of all AMMs
+	lowD, _ := num.UintFromDecimal(lowestBound)
+	if accLow.LTE(lowD) {
+		accLow = lowD.Clone()
+		estLow = lowD.Clone()
+	}
+
+	highD, _ := num.UintFromDecimal(highestBound)
+	if accHigh.GTE(highD) {
+		accHigh = highD.Clone()
+		estHigh = highD.Clone()
+	}
+
+	// need to find the first n such that
+	// accLow - (n * eStep) < lowD
+	// accLow
+	if estLow.LT(lowD) {
+		delta, _ := num.UintZero().Delta(accLow, lowD)
+		delta.Div(delta, eStep)
+		estLow = num.UintZero().Sub(accLow, delta.Mul(delta, eStep))
+	}
+
+	if estHigh.GT(highD) {
+		delta, _ := num.UintZero().Delta(accHigh, highD)
+		delta.Div(delta, eStep)
+		estHigh = num.UintZero().Add(accHigh, delta.Mul(delta, eStep))
+	}
+
 	levels := []*level{}
 
 	// we now have our four prices [estLow, accLow, accHigh, estHigh] where from
@@ -164,6 +199,10 @@ func (m *MarketDepth) getCalculationBounds(reference num.Decimal, priceFactor nu
 		price = num.UintZero().Add(price, eStep)
 	}
 
+	cache.levels = map[string][]*level{
+		reference.String(): levels,
+	}
+
 	return levels
 }
 
@@ -268,7 +307,6 @@ func (m *MarketDepth) expandByLevels(pool entities.AMMPool, levels []*level, pri
 				v1 = ammDefn.position
 			}
 		}
-
 		// calculate the volume
 		volume := v1.Sub(v2).Abs().IntPart()
 
@@ -303,7 +341,7 @@ func (m *MarketDepth) InitialiseAMMs(ctx context.Context) {
 
 		// add it to our active list, we want to do this even if we fail to get a reference
 		for _, a := range amms {
-			cache.activeAMMs[a.AmmPartyID.String()] = a
+			cache.addAMM(a)
 		}
 
 		reference, err := m.getReference(ctx, marketID)
@@ -311,7 +349,7 @@ func (m *MarketDepth) InitialiseAMMs(ctx context.Context) {
 			continue
 		}
 
-		levels := m.getCalculationBounds(reference, priceFactor)
+		levels := m.getCalculationBounds(cache, reference, priceFactor)
 
 		for _, amm := range amms {
 			orders, estimated, err := m.expandByLevels(amm, levels, priceFactor)
@@ -345,7 +383,12 @@ func (m *MarketDepth) ExpandAMM(ctx context.Context, pool entities.AMMPool, pric
 		return nil, nil, err
 	}
 
-	levels := m.getCalculationBounds(reference, priceFactor)
+	cache, err := m.getAMMCache(string(pool.MarketID))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	levels := m.getCalculationBounds(cache, reference, priceFactor)
 
 	return m.expandByLevels(pool, levels, priceFactor)
 }
@@ -391,11 +434,12 @@ func (m *MarketDepth) refreshAMM(pool entities.AMMPool, depth *entities.MarketDe
 	}
 
 	if pool.Status == entities.AMMStatusCancelled || pool.Status == entities.AMMStatusStopped {
-		delete(cache.activeAMMs, ammParty)
-		delete(cache.ammOrders, ammParty)
+		cache.removeAMM(ammParty)
 		return
 	}
 
+	cache.addAMM(pool)
+
 	// expand it again into new orders and push them into the market depth
 	orders, estimated, _ := m.ExpandAMM(context.Background(), pool, cache.priceFactor)
 	for i := range orders {
@@ -404,9 +448,7 @@ func (m *MarketDepth) refreshAMM(pool entities.AMMPool, depth *entities.MarketDe
 			cache.estimatedOrder[orders[i].ID] = struct{}{}
 		}
 	}
-
 	cache.ammOrders[ammParty] = orders
-	cache.activeAMMs[ammParty] = pool
 }
 
 // refreshAMM is used when an AMM has either traded or its definition has changed.
@@ -484,6 +526,7 @@ func (m *MarketDepth) getAMMCache(marketID string) (*ammCache, error) {
 		ammOrders:      map[string][]*types.Order{},
 		activeAMMs:     map[string]entities.AMMPool{},
 		estimatedOrder: map[string]struct{}{},
+		levels:         map[string][]*level{},
 	}
 	m.ammCache[marketID] = cache
 
diff --git a/datanode/service/market_depth_amm_test.go b/datanode/service/market_depth_amm_test.go
index 3b3bc0df64..a729e56477 100644
--- a/datanode/service/market_depth_amm_test.go
+++ b/datanode/service/market_depth_amm_test.go
@@ -277,6 +277,82 @@ func TestEstimatedStepOverAMMBound(t *testing.T) {
 	assert.Equal(t, 3, int(mds.service.GetVolumeAtPrice(marketID, types.SideSell, 2001)))
 }
 
+func TestExpansionMuchBiggerThanAMMs(t *testing.T) {
+	ctx := context.Background()
+
+	cfg := service.MarketDepthConfig{
+		AmmFullExpansionPercentage: 1,
+		AmmMaxEstimatedSteps:       10,
+		AmmEstimatedStepPercentage: 5,
+	}
+
+	mds := getServiceWithConfig(t, cfg)
+	defer mds.ctrl.Finish()
+
+	marketID := vgcrypto.RandomHash()
+
+	ensureLiveOrders(t, mds, marketID)
+	ensureDecimalPlaces(t, mds)
+	mds.pos.EXPECT().GetByMarketAndParty(gomock.Any(), gomock.Any(), gomock.Any()).Return(entities.Position{OpenVolume: 0}, nil)
+	mds.marketData.EXPECT().GetMarketDataByID(gomock.Any(), gomock.Any()).Times(1).Return(entities.MarketData{MidPrice: num.DecimalFromInt64(2000)}, nil)
+
+	// data node is starting from network history, initialise market-depth based on whats aleady there
+	ensureAMMs(t, mds, marketID)
+	mds.service.Initialise(ctx)
+
+	assert.Equal(t, 465, int(mds.service.GetTotalAMMVolume(marketID)))
+	assert.Equal(t, 345, int(mds.service.GetAMMVolume(marketID, true)))
+	assert.Equal(t, 120, int(mds.service.GetAMMVolume(marketID, false)))
+	assert.Equal(t, 485, int(mds.service.GetTotalVolume(marketID)))
+
+	assert.Equal(t, "1999", mds.service.GetBestBidPrice(marketID).String())
+	assert.Equal(t, "2001", mds.service.GetBestAskPrice(marketID).String())
+}
+
+func TestMidPriceMove(t *testing.T) {
+	ctx := context.Background()
+
+	mds := getService(t)
+	defer mds.ctrl.Finish()
+
+	marketID := vgcrypto.RandomHash()
+
+	ensureLiveOrders(t, mds, marketID)
+	ensureDecimalPlaces(t, mds)
+	mds.pos.EXPECT().GetByMarketAndParty(gomock.Any(), gomock.Any(), gomock.Any()).Return(entities.Position{OpenVolume: 0}, nil)
+	mds.marketData.EXPECT().GetMarketDataByID(gomock.Any(), gomock.Any()).Times(1).Return(entities.MarketData{MidPrice: num.DecimalFromInt64(2000)}, nil)
+
+	// data node is starting from network history, initialise market-depth based on whats aleady there
+	pool := ensureAMMs(t, mds, marketID)
+	mds.service.Initialise(ctx)
+
+	assert.Equal(t, 240, int(mds.service.GetTotalAMMVolume(marketID)))
+	assert.Equal(t, 120, int(mds.service.GetAMMVolume(marketID, true)))
+	assert.Equal(t, 120, int(mds.service.GetAMMVolume(marketID, false)))
+	assert.Equal(t, 260, int(mds.service.GetTotalVolume(marketID)))
+
+	assert.Equal(t, "1999", mds.service.GetBestBidPrice(marketID).String())
+	assert.Equal(t, "2001", mds.service.GetBestAskPrice(marketID).String())
+
+	// now say the mid-price moves a little, we want to check we recalculate the levels properly
+	mds.pos.EXPECT().GetByMarketAndParty(gomock.Any(), gomock.Any(), gomock.Any()).Return(entities.Position{OpenVolume: 500}, nil)
+	mds.marketData.EXPECT().GetMarketDataByID(gomock.Any(), gomock.Any()).Times(1).Return(entities.MarketData{MidPrice: num.DecimalFromInt64(1800)}, nil)
+	mds.service.AddOrder(
+		&types.Order{
+			ID:       vgcrypto.RandomHash(),
+			Party:    pool.AmmPartyID.String(),
+			MarketID: marketID,
+			Side:     types.SideBuy,
+			Status:   entities.OrderStatusFilled,
+		},
+		time.Date(2022, 3, 8, 16, 15, 39, 901022000, time.UTC),
+		37,
+	)
+
+	assert.Equal(t, "1828", mds.service.GetBestBidPrice(marketID).String())
+	assert.Equal(t, "3000", mds.service.GetBestAskPrice(marketID).String()) // this is an actual order volume not AMM volume
+}
+
 func ensureLiveOrders(t *testing.T, mds *MDS, marketID string) {
 	t.Helper()
 	mds.orders.EXPECT().GetLiveOrders(gomock.Any()).Return([]entities.Order{
@@ -285,7 +361,7 @@ func ensureLiveOrders(t *testing.T, mds *MDS, marketID string) {
 			MarketID:  entities.MarketID(marketID),
 			PartyID:   entities.PartyID(vgcrypto.RandomHash()),
 			Side:      types.SideBuy,
-			Price:     decimal.NewFromInt(1800),
+			Price:     decimal.NewFromInt(1000),
 			Size:      10,
 			Remaining: 10,
 			Type:      entities.OrderTypeLimit,
@@ -300,7 +376,7 @@ func ensureLiveOrders(t *testing.T, mds *MDS, marketID string) {
 			Side:      types.SideSell,
 			Type:      entities.OrderTypeLimit,
 			Status:    entities.OrderStatusActive,
-			Price:     decimal.NewFromInt(2200),
+			Price:     decimal.NewFromInt(3000),
 			Size:      10,
 			Remaining: 10,
 			VegaTime:  time.Date(2022, 3, 8, 14, 15, 39, 901022000, time.UTC),
diff --git a/protos/blockexplorer/api/v1/blockexplorer.pb.go b/protos/blockexplorer/api/v1/blockexplorer.pb.go
index 4c36503ba6..441b697f7d 100644
--- a/protos/blockexplorer/api/v1/blockexplorer.pb.go
+++ b/protos/blockexplorer/api/v1/blockexplorer.pb.go
@@ -656,7 +656,7 @@ var file_blockexplorer_api_v1_blockexplorer_proto_rawDesc = []byte{
 	0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x72, 0x65, 0x72, 0x2f, 0x61,
 	0x70, 0x69, 0x2f, 0x76, 0x31, 0x92, 0x41, 0x3e, 0x12, 0x23, 0x0a, 0x18, 0x56, 0x65, 0x67, 0x61,
 	0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x72, 0x65, 0x72, 0x20,
-	0x41, 0x50, 0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x33, 0x1a, 0x13, 0x6c,
+	0x41, 0x50, 0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x34, 0x1a, 0x13, 0x6c,
 	0x62, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x2e, 0x76, 0x65, 0x67, 0x61, 0x2e, 0x78,
 	0x79, 0x7a, 0x2a, 0x02, 0x01, 0x02, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
diff --git a/protos/data-node/api/v2/trading_data.pb.go b/protos/data-node/api/v2/trading_data.pb.go
index 4f6643da1e..763d8789c0 100644
--- a/protos/data-node/api/v2/trading_data.pb.go
+++ b/protos/data-node/api/v2/trading_data.pb.go
@@ -32009,7 +32009,7 @@ var file_data_node_api_v2_trading_data_proto_rawDesc = []byte{
 	0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x2d, 0x6e, 0x6f,
 	0x64, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x32, 0x92, 0x41, 0x8f, 0x01, 0x12, 0x1e, 0x0a,
 	0x13, 0x56, 0x65, 0x67, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20,
-	0x41, 0x50, 0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x33, 0x1a, 0x1c, 0x68,
+	0x41, 0x50, 0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x34, 0x1a, 0x1c, 0x68,
 	0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x6e,
 	0x65, 0x74, 0x2e, 0x76, 0x65, 0x67, 0x61, 0x2e, 0x78, 0x79, 0x7a, 0x2a, 0x02, 0x01, 0x02, 0x32,
 	0x10, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x6a, 0x73, 0x6f,
diff --git a/protos/sources/blockexplorer/api/v1/blockexplorer.proto b/protos/sources/blockexplorer/api/v1/blockexplorer.proto
index c515892a83..3dc6bc394d 100644
--- a/protos/sources/blockexplorer/api/v1/blockexplorer.proto
+++ b/protos/sources/blockexplorer/api/v1/blockexplorer.proto
@@ -11,7 +11,7 @@ option go_package = "code.vegaprotocol.io/vega/protos/blockexplorer/api/v1";
 option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   info: {
     title: "Vega block explorer APIs";
-    version: "v0.77.3";
+    version: "v0.77.4";
   }
   schemes: [
     HTTP,
diff --git a/protos/sources/data-node/api/v2/trading_data.proto b/protos/sources/data-node/api/v2/trading_data.proto
index 05c7682247..32a1c12270 100644
--- a/protos/sources/data-node/api/v2/trading_data.proto
+++ b/protos/sources/data-node/api/v2/trading_data.proto
@@ -17,7 +17,7 @@ option go_package = "code.vegaprotocol.io/vega/protos/data-node/api/v2";
 option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   info: {
     title: "Vega data node APIs";
-    version: "v0.77.3";
+    version: "v0.77.4";
   }
   schemes: [
     HTTP,
diff --git a/protos/sources/vega/api/v1/core.proto b/protos/sources/vega/api/v1/core.proto
index 7443cbe231..d87ee9b516 100644
--- a/protos/sources/vega/api/v1/core.proto
+++ b/protos/sources/vega/api/v1/core.proto
@@ -12,7 +12,7 @@ option go_package = "code.vegaprotocol.io/vega/protos/vega/api/v1";
 option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   info: {
     title: "Vega core APIs";
-    version: "v0.77.3";
+    version: "v0.77.4";
   }
   schemes: [
     HTTP,
diff --git a/protos/sources/vega/api/v1/corestate.proto b/protos/sources/vega/api/v1/corestate.proto
index 12f3939dcd..dc38817d99 100644
--- a/protos/sources/vega/api/v1/corestate.proto
+++ b/protos/sources/vega/api/v1/corestate.proto
@@ -13,7 +13,7 @@ option go_package = "code.vegaprotocol.io/vega/protos/vega/api/v1";
 option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
   info: {
     title: "Vega core state APIs";
-    version: "v0.77.3";
+    version: "v0.77.4";
   }
   schemes: [
     HTTP,
diff --git a/protos/vega/api/v1/core.pb.go b/protos/vega/api/v1/core.pb.go
index 128af07206..54390719ff 100644
--- a/protos/vega/api/v1/core.pb.go
+++ b/protos/vega/api/v1/core.pb.go
@@ -2796,7 +2796,7 @@ var file_vega_api_v1_core_proto_rawDesc = []byte{
 	0x6f, 0x6c, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x65, 0x67, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 	0x73, 0x2f, 0x76, 0x65, 0x67, 0x61, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x92, 0x41, 0x34,
 	0x12, 0x19, 0x0a, 0x0e, 0x56, 0x65, 0x67, 0x61, 0x20, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x41, 0x50,
-	0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x33, 0x1a, 0x13, 0x6c, 0x62, 0x2e,
+	0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x34, 0x1a, 0x13, 0x6c, 0x62, 0x2e,
 	0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x2e, 0x76, 0x65, 0x67, 0x61, 0x2e, 0x78, 0x79, 0x7a,
 	0x2a, 0x02, 0x01, 0x02, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
diff --git a/protos/vega/api/v1/corestate.pb.go b/protos/vega/api/v1/corestate.pb.go
index 7279b13955..c98b16969d 100644
--- a/protos/vega/api/v1/corestate.pb.go
+++ b/protos/vega/api/v1/corestate.pb.go
@@ -1512,7 +1512,7 @@ var file_vega_api_v1_corestate_proto_rawDesc = []byte{
 	0x6f, 0x73, 0x2f, 0x76, 0x65, 0x67, 0x61, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x92, 0x41,
 	0x3a, 0x12, 0x1f, 0x0a, 0x14, 0x56, 0x65, 0x67, 0x61, 0x20, 0x63, 0x6f, 0x72, 0x65, 0x20, 0x73,
 	0x74, 0x61, 0x74, 0x65, 0x20, 0x41, 0x50, 0x49, 0x73, 0x32, 0x07, 0x76, 0x30, 0x2e, 0x37, 0x37,
-	0x2e, 0x33, 0x1a, 0x13, 0x6c, 0x62, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x2e, 0x76,
+	0x2e, 0x34, 0x1a, 0x13, 0x6c, 0x62, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x2e, 0x76,
 	0x65, 0x67, 0x61, 0x2e, 0x78, 0x79, 0x7a, 0x2a, 0x02, 0x01, 0x02, 0x62, 0x06, 0x70, 0x72, 0x6f,
 	0x74, 0x6f, 0x33,
 }
diff --git a/version/version.go b/version/version.go
index 48b394076d..7810e590b2 100644
--- a/version/version.go
+++ b/version/version.go
@@ -22,7 +22,7 @@ import (
 
 var (
 	cliVersionHash = ""
-	cliVersion     = "v0.77.3"
+	cliVersion     = "v0.77.4"
 )
 
 func init() {