Release v0.76.7

CHANGELOG.md

@@ -19,6 +19,58 @@
 - [](https://github.com/vegaprotocol/vega/issues/xxx)
 
 
+## 0.76.8
+
+### 🐛 Fixes
+
+- [11315](https://github.com/vegaprotocol/vega/pull/11315) - fix node validation governance snapshot.
+
+
+## 0.76.7
+
+### 🐛 Fixes
+
+- [11275](https://github.com/vegaprotocol/vega/pull/11275) - add cache map to order `sqlsubscriber` to prevent order from not being updated in data node.
+- [11310](https://github.com/vegaprotocol/vega/pull/11310) - handle invalid offset for pegged on market update when tick size changes.
+
+
+## 0.76.6
+
+### 🐛 Fixes
+
+- [11306](https://github.com/vegaprotocol/vega/pull/11306) - More fixes regarding pegged orders.
+
+
+## 0.76.5
+
+### 🐛 Fixes
+
+- [11304](https://github.com/vegaprotocol/vega/issues/11304) - Correctly verify pegged order offset with respect to tick size in the right units.
+
+
+## 0.76.4
+
+### 🐛 Fixes
+
+- [11293](https://github.com/vegaprotocol/vega/issues/11293) - Panic in data node with position estimate endpoint.
+- [11297](https://github.com/vegaprotocol/vega/issues/11297) - Handle properly asset decimals < market decimals when uncrossing the order book upon leaving auction.
+
+
+## 0.76.3
+
+### 🐛 Fixes
+
+- [11284](https://github.com/vegaprotocol/vega/pull/11284) - Do not account for started block in the past block range.
+
+
+## 0.76.2
+
+### 🐛 Fixes
+
+- [11262](https://github.com/vegaprotocol/vega/pull/11262) - Fix auction extensions after risk parameter update.
+-  Add validators testnet bridge and multisig address
+
+
 ## 0.76.1
 
 ### 🐛 Fixes

core/datasource/external/ethcall/engine.go

@@ -321,7 +321,7 @@ func (e *Engine) Poll(ctx context.Context, wallTime time.Time) {
 			if call.triggered(prevEthBlock, nextEthBlockIsh) {
 				res, err := call.Call(ctx, e.client, nextEthBlock.Number.Uint64())
 				if err != nil {
-					e.log.Error("failed to call contract", logging.Error(err), logging.Uint64("chain-id", e.chainID.Load()))
+					e.log.Error("failed to call contract", logging.Error(err), logging.String("spec-id", specID), logging.Uint64("chain-id", e.chainID.Load()))
 					event := makeErrorChainEvent(err.Error(), specID, nextEthBlockIsh, e.chainID.Load())
 					e.forwarder.ForwardFromSelf(event)
 					e.lastSent = nextEthBlockIsh

core/execution/common/interfaces.go

@@ -59,7 +59,7 @@ type PriceMonitor interface {
 	Changed() bool
 	IsBoundFactorsInitialised() bool
 	Initialised() bool
-	UpdateSettings(risk.Model, *types.PriceMonitoringSettings)
+	UpdateSettings(risk.Model, *types.PriceMonitoringSettings, price.AuctionState)
 }
 
 // TimeService ...

core/execution/future/market.go

@@ -602,7 +602,7 @@ func (m *Market) Update(ctx context.Context, config *types.Market, oracleEngine
 	m.risk.UpdateModel(m.stateVarEngine, m.tradableInstrument.MarginCalculator, m.tradableInstrument.RiskModel, m.mkt.LinearSlippageFactor, m.mkt.QuadraticSlippageFactor)
 	m.settlement.UpdateProduct(m.tradableInstrument.Instrument.Product)
 	m.tsCalc.UpdateParameters(*m.mkt.LiquidityMonitoringParameters.TargetStakeParameters)
-	m.pMonitor.UpdateSettings(m.tradableInstrument.RiskModel, m.mkt.PriceMonitoringSettings)
+	m.pMonitor.UpdateSettings(m.tradableInstrument.RiskModel, m.mkt.PriceMonitoringSettings, m.as)
 	m.liquidity.UpdateMarketConfig(m.tradableInstrument.RiskModel, m.pMonitor)
 	if err := m.markPriceCalculator.UpdateConfig(ctx, oracleEngine, m.mkt.MarkPriceConfiguration); err != nil {
 		m.markPriceCalculator.SetOraclePriceScalingFunc(m.scaleOracleData)
@@ -643,6 +643,8 @@ func (m *Market) Update(ctx context.Context, config *types.Market, oracleEngine
 	if tickSizeChanged {
 		peggedOrders := m.matching.GetActivePeggedOrderIDs()
 		peggedOrders = append(peggedOrders, m.peggedOrders.GetParkedIDs()...)
+
+		tickSizeInAsset, _ := num.UintFromDecimal(m.mkt.TickSize.ToDecimal().Mul(m.priceFactor))
 		for _, po := range peggedOrders {
 			order, err := m.matching.GetOrderByID(po)
 			if err != nil {
@@ -651,7 +653,9 @@ func (m *Market) Update(ctx context.Context, config *types.Market, oracleEngine
 					continue
 				}
 			}
-			if !num.UintZero().Mod(order.PeggedOrder.Offset, m.mkt.TickSize).IsZero() {
+			offsetInAsset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+			if !num.UintZero().Mod(order.PeggedOrder.Offset, m.mkt.TickSize).IsZero() ||
+				(order.PeggedOrder.Reference == types.PeggedReferenceMid && offsetInAsset.IsZero() && tickSizeInAsset.IsZero()) {
 				m.cancelOrder(ctx, order.Party, order.ID)
 			}
 		}
@@ -1374,26 +1378,30 @@ func (m *Market) getNewPeggedPrice(order *types.Order) (*num.Uint, error) {
 		return num.UintZero(), common.ErrUnableToReprice
 	}
 
-	offset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+	// we're converting both offset and tick size to asset decimals so we can adjust the price (in asset) directly
+	priceInMarket, _ := num.UintFromDecimal(price.ToDecimal().Div(m.priceFactor))
 	if order.Side == types.SideSell {
-		price = price.AddSum(offset)
+		priceInMarket.AddSum(order.PeggedOrder.Offset)
 		// this can only happen when pegged to mid, in which case we want to round to the nearest *better* tick size
 		// but this can never cross the mid by construction as the the minimum offset is 1 tick size and all prices must be
 		// whole multiples of tick size.
-		if mod := num.UintZero().Mod(price, m.mkt.TickSize); !mod.IsZero() {
-			price.Sub(price, mod)
+		if mod := num.UintZero().Mod(priceInMarket, m.mkt.TickSize); !mod.IsZero() {
+			priceInMarket.Sub(priceInMarket, mod)
 		}
+		price, _ := num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
+
 		return price, nil
 	}
 
-	if price.LTE(offset) {
+	if priceInMarket.LTE(order.PeggedOrder.Offset) {
 		return num.UintZero(), common.ErrUnableToReprice
 	}
 
-	price.Sub(price, offset)
-	if mod := num.UintZero().Mod(price, m.mkt.TickSize); !mod.IsZero() {
-		price = num.UintZero().Sub(price.AddSum(m.mkt.TickSize), mod)
+	priceInMarket.Sub(priceInMarket, order.PeggedOrder.Offset)
+	if mod := num.UintZero().Mod(priceInMarket, m.mkt.TickSize); !mod.IsZero() {
+		priceInMarket = num.UintZero().Sub(priceInMarket.AddSum(m.mkt.TickSize), mod)
 	}
+	price, _ = num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
 
 	return price, nil
 }
@@ -1782,6 +1790,13 @@ func (m *Market) validateOrder(ctx context.Context, order *types.Order) (err err
 			}
 			return reason
 		}
+		if order.PeggedOrder.Reference == types.PeggedReferenceMid {
+			offsetInAsset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+			tickSizeInAsset, _ := num.UintFromDecimal(m.mkt.TickSize.ToDecimal().Mul(m.priceFactor))
+			if offsetInAsset.IsZero() && tickSizeInAsset.IsZero() {
+				return fmt.Errorf("invalid offset - pegged mid will cross")
+			}
+		}
 		return m.validateTickSize(order.PeggedOrder.Offset)
 	}
 
@@ -1792,6 +1807,8 @@ func (m *Market) validateOrder(ctx context.Context, order *types.Order) (err err
 	return nil
 }
 
+// validateOrder checks that the order parameters are valid for the market.
+// NB: price in market, tickSize in market decimals.
 func (m *Market) validateTickSize(price *num.Uint) error {
 	d := num.UintZero().Mod(price, m.mkt.TickSize)
 	if !d.IsZero() {

core/execution/spot/market.go

@@ -292,11 +292,12 @@ func (m *Market) Update(ctx context.Context, config *types.Market) error {
 	if err != nil {
 		return err
 	}
-	m.pMonitor.UpdateSettings(riskModel, m.mkt.PriceMonitoringSettings)
+	m.pMonitor.UpdateSettings(riskModel, m.mkt.PriceMonitoringSettings, m.as)
 	m.liquidity.UpdateMarketConfig(riskModel, m.pMonitor)
 	m.updateLiquidityFee(ctx)
 
 	if tickSizeChanged {
+		tickSizeInAsset, _ := num.UintFromDecimal(m.mkt.TickSize.ToDecimal().Mul(m.priceFactor))
 		peggedOrders := m.matching.GetActivePeggedOrderIDs()
 		peggedOrders = append(peggedOrders, m.peggedOrders.GetParkedIDs()...)
 		for _, po := range peggedOrders {
@@ -307,7 +308,9 @@ func (m *Market) Update(ctx context.Context, config *types.Market) error {
 					continue
 				}
 			}
-			if !num.UintZero().Mod(order.PeggedOrder.Offset, m.mkt.TickSize).IsZero() {
+			offsetInAsset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+			if !num.UintZero().Mod(order.PeggedOrder.Offset, m.mkt.TickSize).IsZero() ||
+				(order.PeggedOrder.Reference == types.PeggedReferenceMid && offsetInAsset.IsZero() && tickSizeInAsset.IsZero()) {
 				m.cancelOrder(ctx, order.Party, order.ID)
 			}
 		}
@@ -819,26 +822,29 @@ func (m *Market) getNewPeggedPrice(order *types.Order) (*num.Uint, error) {
 		return num.UintZero(), common.ErrUnableToReprice
 	}
 
-	offset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+	// we're converting both offset and tick size to asset decimals so we can adjust the price (in asset) directly
+	priceInMarket, _ := num.UintFromDecimal(price.ToDecimal().Div(m.priceFactor))
 	if order.Side == types.SideSell {
-		price = price.AddSum(offset)
+		priceInMarket.AddSum(order.PeggedOrder.Offset)
 		// this can only happen when pegged to mid, in which case we want to round to the nearest *better* tick size
 		// but this can never cross the mid by construction as the the minimum offset is 1 tick size and all prices must be
 		// whole multiples of tick size.
-		if mod := num.UintZero().Mod(price, m.mkt.TickSize); !mod.IsZero() {
-			price.Sub(price, mod)
+		if mod := num.UintZero().Mod(priceInMarket, m.mkt.TickSize); !mod.IsZero() {
+			priceInMarket.Sub(priceInMarket, mod)
 		}
+		price, _ := num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
 		return price, nil
 	}
 
-	if price.LTE(offset) {
+	if priceInMarket.LTE(order.PeggedOrder.Offset) {
 		return num.UintZero(), common.ErrUnableToReprice
 	}
 
-	price.Sub(price, offset)
-	if mod := num.UintZero().Mod(price, m.mkt.TickSize); !mod.IsZero() {
-		price = num.UintZero().Sub(price.AddSum(m.mkt.TickSize), mod)
+	priceInMarket.Sub(priceInMarket, order.PeggedOrder.Offset)
+	if mod := num.UintZero().Mod(priceInMarket, m.mkt.TickSize); !mod.IsZero() {
+		priceInMarket = num.UintZero().Sub(priceInMarket.AddSum(m.mkt.TickSize), mod)
 	}
+	price, _ = num.UintFromDecimal(priceInMarket.ToDecimal().Mul(m.priceFactor))
 
 	return price, nil
 }
@@ -971,6 +977,7 @@ func (m *Market) leaveAuction(ctx context.Context, now time.Time) {
 }
 
 // validateOrder checks that the order parameters are valid for the market.
+// NB: price in market, tickSize in market decimals.
 func (m *Market) validateOrder(ctx context.Context, order *types.Order) (err error) {
 	defer func() {
 		if err != nil {
@@ -1042,6 +1049,13 @@ func (m *Market) validateOrder(ctx context.Context, order *types.Order) (err err
 			}
 			return reason
 		}
+		if order.PeggedOrder.Reference == types.PeggedReferenceMid {
+			offsetInAsset, _ := num.UintFromDecimal(order.PeggedOrder.Offset.ToDecimal().Mul(m.priceFactor))
+			tickSizeInAsset, _ := num.UintFromDecimal(m.mkt.TickSize.ToDecimal().Mul(m.priceFactor))
+			if offsetInAsset.IsZero() && tickSizeInAsset.IsZero() {
+				return fmt.Errorf("invalid offset - pegged mid will cross")
+			}
+		}
 		return m.validateTickSize(order.PeggedOrder.Offset)
 	}
 

core/governance/node_validation.go

@@ -435,9 +435,9 @@ func (n *NodeValidation) restoreBatch(ctx context.Context, pProto *snapshotpb.Ba
 	nbp := &nodeBatchProposal{
 		batchProposal: &batchProposal{
 			BatchProposal: p,
-			yes:           map[string]*types.Vote{},
-			no:            map[string]*types.Vote{},
-			invalidVotes:  map[string]*types.Vote{},
+			yes:           votesAsMapFromProto(pProto.BatchProposal.Yes),
+			no:            votesAsMapFromProto(pProto.BatchProposal.No),
+			invalidVotes:  votesAsMapFromProto(pProto.BatchProposal.Invalid),
 		},
 		nodeProposals: nodeProposals,
 		state:         atomic.Uint32{},