diff --git a/CHANGELOG.md b/CHANGELOG.md index 39d5a1dec63..3db2d2b78cf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ - [11266](https://github.com/vegaprotocol/vega/issues/11266) - Include derived parties rewards API - [11357](https://github.com/vegaprotocol/vega/issues/11357) - Support historical game scores - [11023](https://github.com/vegaprotocol/vega/issues/11023) - Add proposed fees to `vAMM` data. +- [11028](https://github.com/vegaprotocol/vega/issues/11028) - Add API to estimate order book depth based on `vAMM`. ### 🐛 Fixes diff --git a/core/execution/amm/engine.go b/core/execution/amm/engine.go index 40fc5603ace..c5a694e18a8 100644 --- a/core/execution/amm/engine.go +++ b/core/execution/amm/engine.go @@ -89,6 +89,10 @@ type Sqrter struct { cache map[string]num.Decimal } +func NewSqrter() *Sqrter { + return &Sqrter{cache: map[string]num.Decimal{}} +} + // sqrt calculates the square root of the uint and caches it. func (s *Sqrter) sqrt(u *num.Uint) num.Decimal { if r, ok := s.cache[u.String()]; ok { diff --git a/core/execution/amm/estimator.go b/core/execution/amm/estimator.go new file mode 100644 index 00000000000..6dfacd14c31 --- /dev/null +++ b/core/execution/amm/estimator.go @@ -0,0 +1,129 @@ +// Copyright (C) 2023 Gobalsky Labs Limited +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package amm + +import ( + "code.vegaprotocol.io/vega/libs/num" +) + +type EstimatedBounds struct { + PositionSizeAtUpper num.Decimal + PositionSizeAtLower num.Decimal + LossOnCommitmentAtUpper num.Decimal + LossOnCommitmentAtLower num.Decimal + LiquidationPriceAtUpper num.Decimal + LiquidationPriceAtLower num.Decimal +} + +func EstimateBounds( + sqrter *Sqrter, + lowerPrice, basePrice, upperPrice *num.Uint, + leverageLower, leverageUpper num.Decimal, + balance *num.Uint, + linearSlippageFactor, initialMargin, + riskFactorShort, riskFactorLong num.Decimal, +) EstimatedBounds { + // test liquidity unit + unitLower := LiquidityUnit(sqrter, basePrice, lowerPrice) + unitUpper := LiquidityUnit(sqrter, upperPrice, basePrice) + + // test average entry price + avgEntryLower := AverageEntryPrice(sqrter, unitLower, basePrice) + avgEntryUpper := AverageEntryPrice(sqrter, unitUpper, upperPrice) + + // test risk factor + riskFactorLower := RiskFactor(leverageLower, riskFactorLong, linearSlippageFactor, initialMargin) + riskFactorUpper := RiskFactor(leverageUpper, riskFactorShort, linearSlippageFactor, initialMargin) + + lowerPriceD := lowerPrice.ToDecimal() + upperPriceD := upperPrice.ToDecimal() + balanceD := balance.ToDecimal() + + // test position at bounds + boundPosLower := PositionAtLowerBound(riskFactorLower, balanceD, lowerPriceD, avgEntryLower) + boundPosUpper := PositionAtUpperBound(riskFactorUpper, balanceD, upperPriceD, avgEntryUpper) + + // test loss on commitment + lossLower := LossOnCommitment(avgEntryLower, lowerPriceD, boundPosLower) + lossUpper := LossOnCommitment(avgEntryUpper, upperPriceD, boundPosUpper) + + // test liquidation price + liquidationPriceAtLower := LiquidationPrice(balanceD, lossLower, boundPosLower, lowerPriceD, linearSlippageFactor, riskFactorLong) + liquidationPriceAtUpper := LiquidationPrice(balanceD, lossUpper, boundPosUpper, upperPriceD, linearSlippageFactor, riskFactorShort) + + return EstimatedBounds{ + PositionSizeAtUpper: boundPosUpper, + PositionSizeAtLower: boundPosLower, + LossOnCommitmentAtUpper: lossUpper, + LossOnCommitmentAtLower: lossLower, + LiquidationPriceAtUpper: liquidationPriceAtUpper, + LiquidationPriceAtLower: liquidationPriceAtLower, + } +} + +// Lu = (sqrt(pu) * sqrt(pl)) / (sqrt(pu) - sqrt(pl)). +func LiquidityUnit(sqrter *Sqrter, pu, pl *num.Uint) num.Decimal { + sqrtPu := sqrter.sqrt(pu) + sqrtPl := sqrter.sqrt(pl) + + return sqrtPu.Mul(sqrtPl).Div(sqrtPu.Sub(sqrtPl)) +} + +// Rf = min(Lb, 1 / (Fs + Fl) * Fi). +func RiskFactor(lb, fs, fl, fi num.Decimal) num.Decimal { + b := num.DecimalOne().Div(fs.Add(fl).Mul(fi)) + return num.MinD(lb, b) +} + +// Pa = Lu * sqrt(pu) * (1 - (Lu / (Lu + sqrt(pu)))). +func AverageEntryPrice(sqrter *Sqrter, lu num.Decimal, pu *num.Uint) num.Decimal { + sqrtPu := sqrter.sqrt(pu) + // (1 - Lu / (Lu + sqrt(pu))) + oneSubLuDivLuWithUpSquared := num.DecimalOne().Sub(lu.Div(lu.Add(sqrtPu))) + return lu.Mul(sqrtPu).Mul(oneSubLuDivLuWithUpSquared) +} + +// Pvl = rf * b / (pl * (1 - rf) + rf * pa). +func PositionAtLowerBound(rf, b, pl, pa num.Decimal) num.Decimal { + oneSubRf := num.DecimalOne().Sub(rf) + rfMulPa := rf.Mul(pa) + + return rf.Mul(b).Div( + pl.Mul(oneSubRf).Add(rfMulPa), + ) +} + +// Pvl = -rf * b / (pl * (1 + rf) - rf * pa). +func PositionAtUpperBound(rf, b, pl, pa num.Decimal) num.Decimal { + onePlusRf := num.DecimalOne().Add(rf) + rfMulPa := rf.Mul(pa) + + return rf.Neg().Mul(b).Div( + pl.Mul(onePlusRf).Sub(rfMulPa), + ) +} + +// lc = |pa - pb * pB|. +func LossOnCommitment(pa, pb, pB num.Decimal) num.Decimal { + return pa.Sub(pb).Mul(pB).Abs() +} + +// Pliq = (b - lc - Pb * pb) / (|Pb| * (fl + mr) - Pb). +func LiquidationPrice(b, lc, pB, pb, fl, mr num.Decimal) num.Decimal { + return b.Sub(lc).Sub(pB.Mul(pb)).Div( + pB.Abs().Mul(fl.Add(mr)).Sub(pB), + ) +} diff --git a/core/execution/amm/estimator_test.go b/core/execution/amm/estimator_test.go new file mode 100644 index 00000000000..0ad4f869caf --- /dev/null +++ b/core/execution/amm/estimator_test.go @@ -0,0 +1,167 @@ +// Copyright (C) 2023 Gobalsky Labs Limited +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package amm + +import ( + "testing" + + "code.vegaprotocol.io/vega/libs/num" + + "github.com/stretchr/testify/assert" +) + +func TestEstimateSeparateFunctions(t *testing.T) { + balance := num.NewUint(100) + lowerPrice := num.NewUint(900) + basePrice := num.NewUint(1000) + upperPrice := num.NewUint(1300) + leverageAtUpper := num.NewDecimalFromFloat(1.00) + leverageAtLower := num.NewDecimalFromFloat(5.00) + sqrter := NewSqrter() + + shortRiskFactor := num.NewDecimalFromFloat(0.01) + longRiskFactor := num.NewDecimalFromFloat(0.01) + linearSlippage := num.NewDecimalFromFloat(0.05) + initialMargin := num.DecimalOne() + + // test liquidity unit + unitLower := LiquidityUnit(sqrter, basePrice, lowerPrice) + unitUpper := LiquidityUnit(sqrter, upperPrice, basePrice) + + assert.Equal(t, num.DecimalFromFloat(584.6049894).String(), unitLower.Round(7).String()) + assert.Equal(t, num.DecimalFromFloat(257.2170745).String(), unitUpper.Round(7).String()) + + // test average entry price + avgEntryLower := AverageEntryPrice(sqrter, unitLower, basePrice) + avgEntryUpper := AverageEntryPrice(sqrter, unitUpper, upperPrice) + assert.Equal(t, num.DecimalFromFloat(948.683).String(), avgEntryLower.Round(3).String()) + assert.Equal(t, num.DecimalFromFloat(1140.175).String(), avgEntryUpper.Round(3).String()) + + // test risk factor + riskFactorLower := RiskFactor(leverageAtLower, longRiskFactor, linearSlippage, initialMargin) + riskFactorUpper := RiskFactor(leverageAtUpper, shortRiskFactor, linearSlippage, initialMargin) + assert.Equal(t, leverageAtLower.String(), riskFactorLower.String()) + assert.Equal(t, leverageAtUpper.String(), riskFactorUpper.String()) + + lowerPriceD := lowerPrice.ToDecimal() + upperPriceD := upperPrice.ToDecimal() + + // test position at bounds + lowerBoundPos := PositionAtLowerBound(riskFactorLower, balance.ToDecimal(), lowerPriceD, avgEntryLower) + upperBoundPos := PositionAtUpperBound(riskFactorUpper, balance.ToDecimal(), upperPriceD, avgEntryUpper) + assert.Equal(t, num.DecimalFromFloat(0.437).String(), lowerBoundPos.Round(3).String()) + assert.Equal(t, num.DecimalFromFloat(-0.069).String(), upperBoundPos.Round(3).String()) + + // test loss on commitment + lossAtLower := LossOnCommitment(avgEntryLower, lowerPriceD, lowerBoundPos) + lossAtUpper := LossOnCommitment(avgEntryUpper, upperPriceD, upperBoundPos) + assert.Equal(t, num.DecimalFromFloat(21.28852368).String(), lossAtLower.Round(8).String()) + assert.Equal(t, num.DecimalFromFloat(10.94820416).String(), lossAtUpper.Round(8).String()) + + linearSlippageFactor := num.DecimalZero() + + // test liquidation price + liquidationPriceAtLower := LiquidationPrice(balance.ToDecimal(), lossAtLower, lowerBoundPos, lowerPriceD, linearSlippageFactor, longRiskFactor) + liquidationPriceAtUpper := LiquidationPrice(balance.ToDecimal(), lossAtUpper, upperBoundPos, upperPriceD, linearSlippageFactor, shortRiskFactor) + assert.Equal(t, num.DecimalFromFloat(727.2727273).String(), liquidationPriceAtLower.Round(7).String()) + assert.Equal(t, num.DecimalFromFloat(2574.257426).String(), liquidationPriceAtUpper.Round(6).String()) +} + +func TestEstimate(t *testing.T) { + initialMargin := num.DecimalFromFloat(1) + riskFactorShort := num.DecimalFromFloat(0.01) + riskFactorLong := num.DecimalFromFloat(0.01) + linearSlippageFactor := num.DecimalFromFloat(0) + sqrter := NewSqrter() + + t.Run("test 0014-NP-VAMM-001", func(t *testing.T) { + lowerPrice := num.NewUint(900) + basePrice := num.NewUint(1000) + upperPrice := num.NewUint(1100) + leverageUpper := num.DecimalFromFloat(2.00) + leverageLower := num.DecimalFromFloat(2.00) + balance := num.NewUint(100) + + expectedMetrics := EstimatedBounds{ + PositionSizeAtUpper: num.DecimalFromFloat(-0.166), + PositionSizeAtLower: num.DecimalFromFloat(0.201), + LossOnCommitmentAtUpper: num.DecimalFromFloat(8.515), + LossOnCommitmentAtLower: num.DecimalFromFloat(9.762), + LiquidationPriceAtUpper: num.DecimalFromFloat(1633.663), + LiquidationPriceAtLower: num.DecimalFromFloat(454.545), + } + + metrics := EstimateBounds( + sqrter, + lowerPrice, + basePrice, + upperPrice, + leverageLower, + leverageUpper, + balance, + linearSlippageFactor, + initialMargin, + riskFactorShort, + riskFactorLong, + ) + + assert.Equal(t, expectedMetrics.PositionSizeAtUpper.String(), metrics.PositionSizeAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.PositionSizeAtLower.String(), metrics.PositionSizeAtLower.Round(3).String()) + assert.Equal(t, expectedMetrics.LossOnCommitmentAtUpper.String(), metrics.LossOnCommitmentAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.LossOnCommitmentAtLower.String(), metrics.LossOnCommitmentAtLower.Round(3).String()) + assert.Equal(t, expectedMetrics.LiquidationPriceAtUpper.String(), metrics.LiquidationPriceAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.LiquidationPriceAtLower.String(), metrics.LiquidationPriceAtLower.Round(3).String()) + }) + + t.Run("test 0014-NP-VAMM-004", func(t *testing.T) { + lowerPrice := num.NewUint(900) + basePrice := num.NewUint(1000) + upperPrice := num.NewUint(1300) + leverageUpper := num.DecimalFromFloat(1) + leverageLower := num.DecimalFromFloat(5) + balance := num.NewUint(100) + + expectedMetrics := EstimatedBounds{ + PositionSizeAtUpper: num.DecimalFromFloat(-0.069), + PositionSizeAtLower: num.DecimalFromFloat(0.437), + LossOnCommitmentAtUpper: num.DecimalFromFloat(10.948), + LossOnCommitmentAtLower: num.DecimalFromFloat(21.289), + LiquidationPriceAtUpper: num.DecimalFromFloat(2574.257), + LiquidationPriceAtLower: num.DecimalFromFloat(727.273), + } + + metrics := EstimateBounds( + sqrter, + lowerPrice, + basePrice, + upperPrice, + leverageLower, + leverageUpper, + balance, + linearSlippageFactor, + initialMargin, + riskFactorShort, + riskFactorLong, + ) + + assert.Equal(t, expectedMetrics.PositionSizeAtUpper.String(), metrics.PositionSizeAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.PositionSizeAtLower.String(), metrics.PositionSizeAtLower.Round(3).String()) + assert.Equal(t, expectedMetrics.LossOnCommitmentAtUpper.String(), metrics.LossOnCommitmentAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.LossOnCommitmentAtLower.String(), metrics.LossOnCommitmentAtLower.Round(3).String()) + assert.Equal(t, expectedMetrics.LiquidationPriceAtUpper.String(), metrics.LiquidationPriceAtUpper.Round(3).String()) + assert.Equal(t, expectedMetrics.LiquidationPriceAtLower.String(), metrics.LiquidationPriceAtLower.Round(3).String()) + }) +} diff --git a/datanode/api/errors.go b/datanode/api/errors.go index 84c69213e85..e2bea2bc3ed 100644 --- a/datanode/api/errors.go +++ b/datanode/api/errors.go @@ -343,6 +343,15 @@ var ( ErrDateRangeValidationFailed = newInvalidArgumentError("invalid date range") ErrListAMMPools = errors.New("failed to list AMM pools") + + // Amm bounds estimates. + ErrInvalidBasePrice = newInvalidArgumentError("invalid base price") + ErrInvalidUpperPrice = newInvalidArgumentError("invalid upper price") + ErrInvalidLowerPrice = newInvalidArgumentError("invalid lower price") + ErrInvalidLeverageAtLowerPrice = newInvalidArgumentError("invalid leverage at lower price") + ErrInvalidLeverageAtUpperPrice = newInvalidArgumentError("invalid leverage at upper price") + ErrInvalidCommitmentAmount = newInvalidArgumentError("invalid commitment amount") + ErrEstimateAMMBounds = errors.New("failed to estimate AMM bounds") ) // errorMap contains a mapping between errors and Vega numeric error codes. diff --git a/datanode/api/trading_data_v2.go b/datanode/api/trading_data_v2.go index ef2dae5c6b7..2dd4f7f6e94 100644 --- a/datanode/api/trading_data_v2.go +++ b/datanode/api/trading_data_v2.go @@ -5559,3 +5559,110 @@ func (t *TradingDataServiceV2) ListAMMs(ctx context.Context, req *v2.ListAMMsReq }, }, nil } + +func (t *TradingDataServiceV2) EstimateAMMBounds(ctx context.Context, req *v2.EstimateAMMBoundsRequest) (*v2.EstimateAMMBoundsResponse, error) { + defer metrics.StartAPIRequestAndTimeGRPC("EstimateAMMBounds")() + + if req.MarketId == "" { + return nil, formatE(ErrInvalidMarketID) + } + + basePrice, overflow := num.UintFromString(req.BasePrice, 10) + if overflow || basePrice.IsNegative() { + return nil, formatE(ErrInvalidBasePrice) + } + + upperPrice := num.UintZero() + if req.UpperPrice != nil { + upperP, overflow := num.UintFromString(*req.UpperPrice, 10) + if overflow || upperPrice.IsNegative() || upperPrice.LTE(basePrice) { + return nil, formatE(ErrInvalidUpperPrice) + } + upperPrice = upperP + } + + lowerPrice := num.UintZero() + if req.LowerPrice != nil { + lowerP, overflow := num.UintFromString(*req.LowerPrice, 10) + if overflow || lowerPrice.IsNegative() || lowerPrice.GTE(basePrice) { + return nil, formatE(ErrInvalidLowerPrice) + } + lowerPrice = lowerP + } + + var leverageLowerPrice, leverageUpperPrice *num.Decimal + if req.LeverageAtLowerPrice != nil { + llPrice, err := num.DecimalFromString(*req.LeverageAtLowerPrice) + if err != nil || leverageLowerPrice.IsNegative() { + return nil, formatE(ErrInvalidLeverageAtLowerPrice, err) + } + leverageLowerPrice = &llPrice + } + + if req.LeverageAtUpperPrice != nil { + luPrice, err := num.DecimalFromString(*req.LeverageAtUpperPrice) + if err != nil || leverageUpperPrice.IsNegative() { + return nil, formatE(ErrInvalidLeverageAtUpperPrice, err) + } + leverageUpperPrice = &luPrice + } + + commitmentAmount, overflow := num.UintFromString(req.CommitmentAmount, 10) + if overflow || commitmentAmount.IsNegative() { + return nil, formatE(ErrInvalidCommitmentAmount) + } + + // TODO Karel - make the market service and risk factor serices calls concurent + market, err := t.MarketsService.GetByID(ctx, req.MarketId) + if err != nil { + return nil, formatE(ErrEstimateAMMBounds, err) + } + + if market.TradableInstrument.MarginCalculator == nil || + market.TradableInstrument.MarginCalculator.ScalingFactors == nil { + return nil, formatE(ErrEstimateAMMBounds) + } + + if market.LinearSlippageFactor == nil { + return nil, formatE(ErrEstimateAMMBounds) + } + + initialMargin := num.DecimalFromFloat(market.TradableInstrument.MarginCalculator.ScalingFactors.InitialMargin) + linearSlippageFactor := *market.LinearSlippageFactor + + riskFactor, err := t.RiskFactorService.GetMarketRiskFactors(ctx, req.MarketId) + if err != nil { + return nil, formatE(ErrEstimateAMMBounds, err) + } + if leverageLowerPrice == nil { + leverageLowerPrice = &riskFactor.Short + } + if leverageUpperPrice == nil { + leverageUpperPrice = &riskFactor.Long + } + + sqrt := amm.NewSqrter() + + estimatedBounds := amm.EstimateBounds( + sqrt, + lowerPrice, + basePrice, + upperPrice, + *leverageLowerPrice, + *leverageUpperPrice, + commitmentAmount, + linearSlippageFactor, + initialMargin, + riskFactor.Short, + riskFactor.Long, + ) + + return &v2.EstimateAMMBoundsResponse{ + PositionSizeAtUpper: estimatedBounds.PositionSizeAtUpper.String(), + PositionSizeAtLower: estimatedBounds.PositionSizeAtLower.String(), + LossOnCommitmentAtUpper: estimatedBounds.LossOnCommitmentAtUpper.String(), + LossOnCommitmentAtLower: estimatedBounds.LossOnCommitmentAtLower.String(), + LiquidationPriceAtUpper: estimatedBounds.LiquidationPriceAtUpper.String(), + LiquidationPriceAtLower: estimatedBounds.LiquidationPriceAtLower.String(), + }, nil +} diff --git a/datanode/gateway/graphql/generated.go b/datanode/gateway/graphql/generated.go index 6fb27be2221..966343c0ee8 100644 --- a/datanode/gateway/graphql/generated.go +++ b/datanode/gateway/graphql/generated.go @@ -778,6 +778,15 @@ type ComplexityRoot struct { ReceiverAddress func(childComplexity int) int } + EstimatedAMMBounds struct { + LiquidationPriceAtLower func(childComplexity int) int + LiquidationPriceAtUpper func(childComplexity int) int + LossOnCommitmentAtLower func(childComplexity int) int + LossOnCommitmentAtUpper func(childComplexity int) int + PositionSizeAtLower func(childComplexity int) int + PositionSizeAtUpper func(childComplexity int) int + } + EstimatedTransferFee struct { Discount func(childComplexity int) int Fee func(childComplexity int) int @@ -2211,6 +2220,7 @@ type ComplexityRoot struct { Erc20MultiSigSignerRemovedBundles func(childComplexity int, nodeID string, submitter *string, epochSeq *string, chainID *string, pagination *v2.Pagination) int Erc20SetAssetLimitsBundle func(childComplexity int, proposalID string) int Erc20WithdrawalApproval func(childComplexity int, withdrawalID string) int + EstimateAMMBounds func(childComplexity int, basePrice string, upperPrice *string, lowerPrice *string, leverageAtUpperPrice *string, leverageAtLowerPrice *string, commitmentAmount string, marketID string) int EstimateFees func(childComplexity int, marketID string, partyID string, price *string, size string, side vega.Side, timeInForce vega.Order_TimeInForce, expiration *int64, typeArg vega.Order_Type) int EstimateOrder func(childComplexity int, marketID string, partyID string, price *string, size string, side vega.Side, timeInForce vega.Order_TimeInForce, expiration *int64, typeArg vega.Order_Type) int EstimatePosition func(childComplexity int, marketID string, openVolume string, averageEntryPrice string, orders []*v2.OrderInfo, marginAccountBalance string, generalAccountBalance string, orderMarginAccountBalance string, marginMode vega.MarginMode, marginFactor *string, includeRequiredPositionMarginInAvailableCollateral *bool, scaleLiquidationPriceToMarketDecimals *bool) int @@ -3687,6 +3697,7 @@ type QueryResolver interface { EstimateOrder(ctx context.Context, marketID string, partyID string, price *string, size string, side vega.Side, timeInForce vega.Order_TimeInForce, expiration *int64, typeArg vega.Order_Type) (*OrderEstimate, error) EstimateFees(ctx context.Context, marketID string, partyID string, price *string, size string, side vega.Side, timeInForce vega.Order_TimeInForce, expiration *int64, typeArg vega.Order_Type) (*FeeEstimate, error) EstimatePosition(ctx context.Context, marketID string, openVolume string, averageEntryPrice string, orders []*v2.OrderInfo, marginAccountBalance string, generalAccountBalance string, orderMarginAccountBalance string, marginMode vega.MarginMode, marginFactor *string, includeRequiredPositionMarginInAvailableCollateral *bool, scaleLiquidationPriceToMarketDecimals *bool) (*PositionEstimate, error) + EstimateAMMBounds(ctx context.Context, basePrice string, upperPrice *string, lowerPrice *string, leverageAtUpperPrice *string, leverageAtLowerPrice *string, commitmentAmount string, marketID string) (*v2.EstimateAMMBoundsResponse, error) EthereumKeyRotations(ctx context.Context, nodeID *string) (*v2.EthereumKeyRotationsConnection, error) EstimateTransferFee(ctx context.Context, fromAccount string, fromAccountType vega.AccountType, toAccount string, amount string, assetID string) (*v2.EstimateTransferFeeResponse, error) FeesStats(ctx context.Context, marketID *string, assetID *string, epoch *int, partyID *string) (*v1.FeesStats, error) @@ -6420,6 +6431,48 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Erc20WithdrawalDetails.ReceiverAddress(childComplexity), true + case "EstimatedAMMBounds.liquidationPriceAtLower": + if e.complexity.EstimatedAMMBounds.LiquidationPriceAtLower == nil { + break + } + + return e.complexity.EstimatedAMMBounds.LiquidationPriceAtLower(childComplexity), true + + case "EstimatedAMMBounds.liquidationPriceAtUpper": + if e.complexity.EstimatedAMMBounds.LiquidationPriceAtUpper == nil { + break + } + + return e.complexity.EstimatedAMMBounds.LiquidationPriceAtUpper(childComplexity), true + + case "EstimatedAMMBounds.lossOnCommitmentAtLower": + if e.complexity.EstimatedAMMBounds.LossOnCommitmentAtLower == nil { + break + } + + return e.complexity.EstimatedAMMBounds.LossOnCommitmentAtLower(childComplexity), true + + case "EstimatedAMMBounds.lossOnCommitmentAtUpper": + if e.complexity.EstimatedAMMBounds.LossOnCommitmentAtUpper == nil { + break + } + + return e.complexity.EstimatedAMMBounds.LossOnCommitmentAtUpper(childComplexity), true + + case "EstimatedAMMBounds.positionSizeAtLower": + if e.complexity.EstimatedAMMBounds.PositionSizeAtLower == nil { + break + } + + return e.complexity.EstimatedAMMBounds.PositionSizeAtLower(childComplexity), true + + case "EstimatedAMMBounds.positionSizeAtUpper": + if e.complexity.EstimatedAMMBounds.PositionSizeAtUpper == nil { + break + } + + return e.complexity.EstimatedAMMBounds.PositionSizeAtUpper(childComplexity), true + case "EstimatedTransferFee.discount": if e.complexity.EstimatedTransferFee.Discount == nil { break @@ -12779,6 +12832,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.Erc20WithdrawalApproval(childComplexity, args["withdrawalId"].(string)), true + case "Query.estimateAMMBounds": + if e.complexity.Query.EstimateAMMBounds == nil { + break + } + + args, err := ec.field_Query_estimateAMMBounds_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.EstimateAMMBounds(childComplexity, args["basePrice"].(string), args["upperPrice"].(*string), args["lowerPrice"].(*string), args["leverageAtUpperPrice"].(*string), args["leverageAtLowerPrice"].(*string), args["commitmentAmount"].(string), args["marketId"].(string)), true + case "Query.estimateFees": if e.complexity.Query.EstimateFees == nil { break @@ -18278,6 +18343,75 @@ func (ec *executionContext) field_Query_erc20WithdrawalApproval_args(ctx context return args, nil } +func (ec *executionContext) field_Query_estimateAMMBounds_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + var arg0 string + if tmp, ok := rawArgs["basePrice"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("basePrice")) + arg0, err = ec.unmarshalNString2string(ctx, tmp) + if err != nil { + return nil, err + } + } + args["basePrice"] = arg0 + var arg1 *string + if tmp, ok := rawArgs["upperPrice"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("upperPrice")) + arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp) + if err != nil { + return nil, err + } + } + args["upperPrice"] = arg1 + var arg2 *string + if tmp, ok := rawArgs["lowerPrice"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lowerPrice")) + arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp) + if err != nil { + return nil, err + } + } + args["lowerPrice"] = arg2 + var arg3 *string + if tmp, ok := rawArgs["leverageAtUpperPrice"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("leverageAtUpperPrice")) + arg3, err = ec.unmarshalOString2ᚖstring(ctx, tmp) + if err != nil { + return nil, err + } + } + args["leverageAtUpperPrice"] = arg3 + var arg4 *string + if tmp, ok := rawArgs["leverageAtLowerPrice"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("leverageAtLowerPrice")) + arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp) + if err != nil { + return nil, err + } + } + args["leverageAtLowerPrice"] = arg4 + var arg5 string + if tmp, ok := rawArgs["commitmentAmount"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("commitmentAmount")) + arg5, err = ec.unmarshalNString2string(ctx, tmp) + if err != nil { + return nil, err + } + } + args["commitmentAmount"] = arg5 + var arg6 string + if tmp, ok := rawArgs["marketId"]; ok { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("marketId")) + arg6, err = ec.unmarshalNID2string(ctx, tmp) + if err != nil { + return nil, err + } + } + args["marketId"] = arg6 + return args, nil +} + func (ec *executionContext) field_Query_estimateFees_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -37081,6 +37215,252 @@ func (ec *executionContext) fieldContext_Erc20WithdrawalDetails_receiverAddress( return fc, nil } +func (ec *executionContext) _EstimatedAMMBounds_positionSizeAtUpper(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_positionSizeAtUpper(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.PositionSizeAtUpper, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_positionSizeAtUpper(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _EstimatedAMMBounds_positionSizeAtLower(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_positionSizeAtLower(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.PositionSizeAtLower, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_positionSizeAtLower(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _EstimatedAMMBounds_lossOnCommitmentAtUpper(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_lossOnCommitmentAtUpper(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LossOnCommitmentAtUpper, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_lossOnCommitmentAtUpper(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _EstimatedAMMBounds_lossOnCommitmentAtLower(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_lossOnCommitmentAtLower(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LossOnCommitmentAtLower, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_lossOnCommitmentAtLower(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _EstimatedAMMBounds_liquidationPriceAtUpper(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_liquidationPriceAtUpper(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LiquidationPriceAtUpper, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_liquidationPriceAtUpper(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _EstimatedAMMBounds_liquidationPriceAtLower(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateAMMBoundsResponse) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_EstimatedAMMBounds_liquidationPriceAtLower(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.LiquidationPriceAtLower, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_EstimatedAMMBounds_liquidationPriceAtLower(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "EstimatedAMMBounds", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _EstimatedTransferFee_fee(ctx context.Context, field graphql.CollectedField, obj *v2.EstimateTransferFeeResponse) (ret graphql.Marshaler) { fc, err := ec.fieldContext_EstimatedTransferFee_fee(ctx, field) if err != nil { @@ -79546,6 +79926,72 @@ func (ec *executionContext) fieldContext_Query_estimatePosition(ctx context.Cont return fc, nil } +func (ec *executionContext) _Query_estimateAMMBounds(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_estimateAMMBounds(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().EstimateAMMBounds(rctx, fc.Args["basePrice"].(string), fc.Args["upperPrice"].(*string), fc.Args["lowerPrice"].(*string), fc.Args["leverageAtUpperPrice"].(*string), fc.Args["leverageAtLowerPrice"].(*string), fc.Args["commitmentAmount"].(string), fc.Args["marketId"].(string)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*v2.EstimateAMMBoundsResponse) + fc.Result = res + return ec.marshalOEstimatedAMMBounds2ᚖcodeᚗvegaprotocolᚗioᚋvegaᚋprotosᚋdataᚑnodeᚋapiᚋv2ᚐEstimateAMMBoundsResponse(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_estimateAMMBounds(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "positionSizeAtUpper": + return ec.fieldContext_EstimatedAMMBounds_positionSizeAtUpper(ctx, field) + case "positionSizeAtLower": + return ec.fieldContext_EstimatedAMMBounds_positionSizeAtLower(ctx, field) + case "lossOnCommitmentAtUpper": + return ec.fieldContext_EstimatedAMMBounds_lossOnCommitmentAtUpper(ctx, field) + case "lossOnCommitmentAtLower": + return ec.fieldContext_EstimatedAMMBounds_lossOnCommitmentAtLower(ctx, field) + case "liquidationPriceAtUpper": + return ec.fieldContext_EstimatedAMMBounds_liquidationPriceAtUpper(ctx, field) + case "liquidationPriceAtLower": + return ec.fieldContext_EstimatedAMMBounds_liquidationPriceAtLower(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type EstimatedAMMBounds", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_estimateAMMBounds_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_ethereumKeyRotations(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_ethereumKeyRotations(ctx, field) if err != nil { @@ -115592,6 +116038,52 @@ func (ec *executionContext) _Erc20WithdrawalDetails(ctx context.Context, sel ast return out } +var estimatedAMMBoundsImplementors = []string{"EstimatedAMMBounds"} + +func (ec *executionContext) _EstimatedAMMBounds(ctx context.Context, sel ast.SelectionSet, obj *v2.EstimateAMMBoundsResponse) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, estimatedAMMBoundsImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("EstimatedAMMBounds") + case "positionSizeAtUpper": + out.Values[i] = ec._EstimatedAMMBounds_positionSizeAtUpper(ctx, field, obj) + case "positionSizeAtLower": + out.Values[i] = ec._EstimatedAMMBounds_positionSizeAtLower(ctx, field, obj) + case "lossOnCommitmentAtUpper": + out.Values[i] = ec._EstimatedAMMBounds_lossOnCommitmentAtUpper(ctx, field, obj) + case "lossOnCommitmentAtLower": + out.Values[i] = ec._EstimatedAMMBounds_lossOnCommitmentAtLower(ctx, field, obj) + case "liquidationPriceAtUpper": + out.Values[i] = ec._EstimatedAMMBounds_liquidationPriceAtUpper(ctx, field, obj) + case "liquidationPriceAtLower": + out.Values[i] = ec._EstimatedAMMBounds_liquidationPriceAtLower(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + var estimatedTransferFeeImplementors = []string{"EstimatedTransferFee"} func (ec *executionContext) _EstimatedTransferFee(ctx context.Context, sel ast.SelectionSet, obj *v2.EstimateTransferFeeResponse) graphql.Marshaler { @@ -133925,6 +134417,25 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "estimateAMMBounds": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_estimateAMMBounds(ctx, field) + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "ethereumKeyRotations": field := field @@ -152233,6 +152744,13 @@ func (ec *executionContext) marshalOErc20WithdrawalApproval2ᚖcodeᚗvegaprotoc return ec._Erc20WithdrawalApproval(ctx, sel, v) } +func (ec *executionContext) marshalOEstimatedAMMBounds2ᚖcodeᚗvegaprotocolᚗioᚋvegaᚋprotosᚋdataᚑnodeᚋapiᚋv2ᚐEstimateAMMBoundsResponse(ctx context.Context, sel ast.SelectionSet, v *v2.EstimateAMMBoundsResponse) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._EstimatedAMMBounds(ctx, sel, v) +} + func (ec *executionContext) marshalOEstimatedTransferFee2ᚖcodeᚗvegaprotocolᚗioᚋvegaᚋprotosᚋdataᚑnodeᚋapiᚋv2ᚐEstimateTransferFeeResponse(ctx context.Context, sel ast.SelectionSet, v *v2.EstimateTransferFeeResponse) graphql.Marshaler { if v == nil { return graphql.Null diff --git a/datanode/gateway/graphql/gqlgen.yml b/datanode/gateway/graphql/gqlgen.yml index 9980df722c3..e99558c8239 100644 --- a/datanode/gateway/graphql/gqlgen.yml +++ b/datanode/gateway/graphql/gqlgen.yml @@ -831,3 +831,5 @@ models: model: code.vegaprotocol.io/vega/protos/vega.RiskFactorOverride FutureCap: model: code.vegaprotocol.io/vega/protos/vega.FutureCap + EstimatedAMMBounds: + model: code.vegaprotocol.io/vega/protos/data-node/api/v2.EstimateAMMBoundsResponse diff --git a/datanode/gateway/graphql/mocks/mocks.go b/datanode/gateway/graphql/mocks/mocks.go index b57d972696b..e41a0d67912 100644 --- a/datanode/gateway/graphql/mocks/mocks.go +++ b/datanode/gateway/graphql/mocks/mocks.go @@ -260,6 +260,26 @@ func (m *MockTradingDataServiceClientV2) EXPECT() *MockTradingDataServiceClientV return m.recorder } +// EstimateAMMBounds mocks base method. +func (m *MockTradingDataServiceClientV2) EstimateAMMBounds(arg0 context.Context, arg1 *v2.EstimateAMMBoundsRequest, arg2 ...grpc.CallOption) (*v2.EstimateAMMBoundsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EstimateAMMBounds", varargs...) + ret0, _ := ret[0].(*v2.EstimateAMMBoundsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EstimateAMMBounds indicates an expected call of EstimateAMMBounds. +func (mr *MockTradingDataServiceClientV2MockRecorder) EstimateAMMBounds(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateAMMBounds", reflect.TypeOf((*MockTradingDataServiceClientV2)(nil).EstimateAMMBounds), varargs...) +} + // EstimateFee mocks base method. func (m *MockTradingDataServiceClientV2) EstimateFee(arg0 context.Context, arg1 *v2.EstimateFeeRequest, arg2 ...grpc.CallOption) (*v2.EstimateFeeResponse, error) { m.ctrl.T.Helper() diff --git a/datanode/gateway/graphql/resolvers.go b/datanode/gateway/graphql/resolvers.go index 5bafb6c688e..2c7840d1d38 100644 --- a/datanode/gateway/graphql/resolvers.go +++ b/datanode/gateway/graphql/resolvers.go @@ -784,6 +784,23 @@ func (r *myDepositResolver) CreditedTimestamp(_ context.Context, obj *vegapb.Dep type myQueryResolver VegaResolverRoot +func (r *myQueryResolver) EstimateAMMBounds(ctx context.Context, basePrice string, upperPrice, lowerPrice, leverageAtUpperPrice, leverageAtLowerPrice *string, commitmentAmount string, marketID string) (*v2.EstimateAMMBoundsResponse, error) { + res, err := r.tradingDataClientV2.EstimateAMMBounds(ctx, &v2.EstimateAMMBoundsRequest{ + BasePrice: basePrice, + UpperPrice: upperPrice, + LowerPrice: lowerPrice, + LeverageAtUpperPrice: leverageAtUpperPrice, + LeverageAtLowerPrice: leverageAtLowerPrice, + CommitmentAmount: commitmentAmount, + MarketId: marketID, + }) + if err != nil { + return nil, err + } + + return res, nil +} + func (r *myQueryResolver) TimeWeightedNotionalPosition(ctx context.Context, assetID, partyID, gameID string, epoch *int) (*v2.TimeWeightedNotionalPosition, error) { var atEpoch *uint64 if epoch != nil { diff --git a/datanode/gateway/graphql/schema.graphql b/datanode/gateway/graphql/schema.graphql index 2b913578f80..22f748074e9 100644 --- a/datanode/gateway/graphql/schema.graphql +++ b/datanode/gateway/graphql/schema.graphql @@ -772,6 +772,33 @@ type Query { scaleLiquidationPriceToMarketDecimals: Boolean ): PositionEstimate + "Estimate bounds for an AMM pool." + estimateAMMBounds( + """ + Base price of the AMM pool, the price is an integer, for example `123456` is a correctly + formatted price of `1.23456` assuming market configured to 5 decimal places. + """ + basePrice:String! + """ + Upper price of the AMM pool, the price is an integer, for example `123456` is a correctly + formatted price of `1.23456` assuming market configured to 5 decimal places. + """ + upperPrice: String + """ + Lower price of the AMM pool, the price is an integer, for example `123456` is a correctly + formatted price of `1.23456` assuming market configured to 5 decimal places. + """ + lowerPrice: String + "Leverage at the upper price of the AMM pool." + leverageAtUpperPrice: String + "Leverage at the lower price of the AMM pool." + leverageAtLowerPrice: String + "Amount of the asset that the party is willing to commit to the AMM pool." + commitmentAmount: String! + "Market ID to filter for." + marketId: ID! + ): EstimatedAMMBounds + "Query for historic ethereum key rotations" ethereumKeyRotations(nodeId: ID): EthereumKeyRotationsConnection! @@ -1329,6 +1356,21 @@ type Query { ): PartyMarginModesConnection } +type EstimatedAMMBounds { + "Theoretical volume at the top of the upper bound." + positionSizeAtUpper: String + "Theoretical volume at the top of the lower bound." + positionSizeAtLower: String + "Loss of commitment at the upper bound." + lossOnCommitmentAtUpper: String + "Loss of commitment at the lower bound." + lossOnCommitmentAtLower: String + "Estimated price above upper bound at which the commitment will be lost." + liquidationPriceAtUpper: String + "Estimated price below the lower bound at which the commitment will be lost." + liquidationPriceAtLower: String +} + "Defines the types of a dispatch strategy's scope the API can filter on." enum TransferScope { "Matches transfers that have dispatch strategy scope of individual set." @@ -1417,7 +1459,7 @@ type RecurringGovernanceTransfer { "An optional dispatch strategy for the recurring transfer" dispatchStrategy: DispatchStrategy "The factor of the initial amount to be distributed" - factor: String + factor: String } "The specific details for a one-off transfer" @@ -2730,7 +2772,7 @@ type Market { "The market minimum tick size" tickSize: String! - + "If enabled aggressive orders sent to the market will be delayed by the configured number of blocks" enableTxReordering: Boolean! } diff --git a/protos/data-node/api/v2/trading_data.pb.go b/protos/data-node/api/v2/trading_data.pb.go index fcb2ae505b6..29691c18ab1 100644 --- a/protos/data-node/api/v2/trading_data.pb.go +++ b/protos/data-node/api/v2/trading_data.pb.go @@ -26750,6 +26750,204 @@ func (x *AMMEdge) GetCursor() string { return "" } +type EstimateAMMBoundsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Base price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + BasePrice string `protobuf:"bytes,1,opt,name=base_price,json=basePrice,proto3" json:"base_price,omitempty"` + // Upper price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + UpperPrice *string `protobuf:"bytes,2,opt,name=upper_price,json=upperPrice,proto3,oneof" json:"upper_price,omitempty"` + // Lower price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + LowerPrice *string `protobuf:"bytes,3,opt,name=lower_price,json=lowerPrice,proto3,oneof" json:"lower_price,omitempty"` + // Leverage at the upper price of the AMM pool. + LeverageAtUpperPrice *string `protobuf:"bytes,4,opt,name=leverage_at_upper_price,json=leverageAtUpperPrice,proto3,oneof" json:"leverage_at_upper_price,omitempty"` + // Leverage at the lower price of the AMM pool. + LeverageAtLowerPrice *string `protobuf:"bytes,5,opt,name=leverage_at_lower_price,json=leverageAtLowerPrice,proto3,oneof" json:"leverage_at_lower_price,omitempty"` + // Amount of the asset that the party is willing to commit to the AMM pool. + CommitmentAmount string `protobuf:"bytes,6,opt,name=commitment_amount,json=commitmentAmount,proto3" json:"commitment_amount,omitempty"` + // Market ID to estimate the AMM for. + MarketId string `protobuf:"bytes,7,opt,name=market_id,json=marketId,proto3" json:"market_id,omitempty"` +} + +func (x *EstimateAMMBoundsRequest) Reset() { + *x = EstimateAMMBoundsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_data_node_api_v2_trading_data_proto_msgTypes[427] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EstimateAMMBoundsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EstimateAMMBoundsRequest) ProtoMessage() {} + +func (x *EstimateAMMBoundsRequest) ProtoReflect() protoreflect.Message { + mi := &file_data_node_api_v2_trading_data_proto_msgTypes[427] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EstimateAMMBoundsRequest.ProtoReflect.Descriptor instead. +func (*EstimateAMMBoundsRequest) Descriptor() ([]byte, []int) { + return file_data_node_api_v2_trading_data_proto_rawDescGZIP(), []int{427} +} + +func (x *EstimateAMMBoundsRequest) GetBasePrice() string { + if x != nil { + return x.BasePrice + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetUpperPrice() string { + if x != nil && x.UpperPrice != nil { + return *x.UpperPrice + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetLowerPrice() string { + if x != nil && x.LowerPrice != nil { + return *x.LowerPrice + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetLeverageAtUpperPrice() string { + if x != nil && x.LeverageAtUpperPrice != nil { + return *x.LeverageAtUpperPrice + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetLeverageAtLowerPrice() string { + if x != nil && x.LeverageAtLowerPrice != nil { + return *x.LeverageAtLowerPrice + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetCommitmentAmount() string { + if x != nil { + return x.CommitmentAmount + } + return "" +} + +func (x *EstimateAMMBoundsRequest) GetMarketId() string { + if x != nil { + return x.MarketId + } + return "" +} + +type EstimateAMMBoundsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Theoretical volume at the top of the upper bound. + PositionSizeAtUpper string `protobuf:"bytes,1,opt,name=position_size_at_upper,json=positionSizeAtUpper,proto3" json:"position_size_at_upper,omitempty"` + // Theoretical volume at the top of the lower bound. + PositionSizeAtLower string `protobuf:"bytes,2,opt,name=position_size_at_lower,json=positionSizeAtLower,proto3" json:"position_size_at_lower,omitempty"` + // Loss of commitment at the upper bound. + LossOnCommitmentAtUpper string `protobuf:"bytes,3,opt,name=loss_on_commitment_at_upper,json=lossOnCommitmentAtUpper,proto3" json:"loss_on_commitment_at_upper,omitempty"` + // Loss of commitment at the lower bound. + LossOnCommitmentAtLower string `protobuf:"bytes,4,opt,name=loss_on_commitment_at_lower,json=lossOnCommitmentAtLower,proto3" json:"loss_on_commitment_at_lower,omitempty"` + // Estimated price above upper bound at which the commitment will be lost. + LiquidationPriceAtUpper string `protobuf:"bytes,5,opt,name=liquidation_price_at_upper,json=liquidationPriceAtUpper,proto3" json:"liquidation_price_at_upper,omitempty"` + // Estimated price below the lower bound at which the commitment will be lost. + LiquidationPriceAtLower string `protobuf:"bytes,6,opt,name=liquidation_price_at_lower,json=liquidationPriceAtLower,proto3" json:"liquidation_price_at_lower,omitempty"` +} + +func (x *EstimateAMMBoundsResponse) Reset() { + *x = EstimateAMMBoundsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_data_node_api_v2_trading_data_proto_msgTypes[428] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EstimateAMMBoundsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EstimateAMMBoundsResponse) ProtoMessage() {} + +func (x *EstimateAMMBoundsResponse) ProtoReflect() protoreflect.Message { + mi := &file_data_node_api_v2_trading_data_proto_msgTypes[428] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EstimateAMMBoundsResponse.ProtoReflect.Descriptor instead. +func (*EstimateAMMBoundsResponse) Descriptor() ([]byte, []int) { + return file_data_node_api_v2_trading_data_proto_rawDescGZIP(), []int{428} +} + +func (x *EstimateAMMBoundsResponse) GetPositionSizeAtUpper() string { + if x != nil { + return x.PositionSizeAtUpper + } + return "" +} + +func (x *EstimateAMMBoundsResponse) GetPositionSizeAtLower() string { + if x != nil { + return x.PositionSizeAtLower + } + return "" +} + +func (x *EstimateAMMBoundsResponse) GetLossOnCommitmentAtUpper() string { + if x != nil { + return x.LossOnCommitmentAtUpper + } + return "" +} + +func (x *EstimateAMMBoundsResponse) GetLossOnCommitmentAtLower() string { + if x != nil { + return x.LossOnCommitmentAtLower + } + return "" +} + +func (x *EstimateAMMBoundsResponse) GetLiquidationPriceAtUpper() string { + if x != nil { + return x.LiquidationPriceAtUpper + } + return "" +} + +func (x *EstimateAMMBoundsResponse) GetLiquidationPriceAtLower() string { + if x != nil { + return x.LiquidationPriceAtLower + } + return "" +} + var File_data_node_api_v2_trading_data_proto protoreflect.FileDescriptor var file_data_node_api_v2_trading_data_proto_rawDesc = []byte{ @@ -30640,7 +30838,57 @@ var file_data_node_api_v2_trading_data_proto_rawDesc = []byte{ 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x65, 0x67, 0x61, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x4d, 0x4d, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x2a, 0xaa, 0x01, 0x0a, 0x10, 0x4c, 0x65, 0x64, + 0x52, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x22, 0x9f, 0x03, 0x0a, 0x18, 0x45, 0x73, 0x74, + 0x69, 0x6d, 0x61, 0x74, 0x65, 0x41, 0x4d, 0x4d, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x61, 0x73, 0x65, 0x50, + 0x72, 0x69, 0x63, 0x65, 0x12, 0x24, 0x0a, 0x0b, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x75, 0x70, 0x70, + 0x65, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x88, 0x01, 0x01, 0x12, 0x24, 0x0a, 0x0b, 0x6c, 0x6f, + 0x77, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x01, 0x52, 0x0a, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x88, 0x01, 0x01, + 0x12, 0x3a, 0x0a, 0x17, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x74, 0x5f, + 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x48, 0x02, 0x52, 0x14, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x41, 0x74, 0x55, + 0x70, 0x70, 0x65, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x88, 0x01, 0x01, 0x12, 0x3a, 0x0a, 0x17, + 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x74, 0x5f, 0x6c, 0x6f, 0x77, 0x65, + 0x72, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, + 0x14, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x41, 0x74, 0x4c, 0x6f, 0x77, 0x65, 0x72, + 0x50, 0x72, 0x69, 0x63, 0x65, 0x88, 0x01, 0x01, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x41, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, + 0x49, 0x64, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x42, 0x1a, 0x0a, 0x18, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, + 0x61, 0x74, 0x5f, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x42, 0x1a, + 0x0a, 0x18, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x74, 0x5f, 0x6c, + 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0xfb, 0x02, 0x0a, 0x19, 0x45, + 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x41, 0x4d, 0x4d, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x61, 0x74, 0x5f, 0x75, 0x70, 0x70, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x41, 0x74, 0x55, 0x70, 0x70, 0x65, 0x72, 0x12, 0x33, 0x0a, + 0x16, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x61, + 0x74, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x41, 0x74, 0x4c, 0x6f, 0x77, + 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x1b, 0x6c, 0x6f, 0x73, 0x73, 0x5f, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x74, 0x5f, 0x75, 0x70, 0x70, 0x65, + 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x6c, 0x6f, 0x73, 0x73, 0x4f, 0x6e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x74, 0x55, 0x70, 0x70, 0x65, 0x72, + 0x12, 0x3c, 0x0a, 0x1b, 0x6c, 0x6f, 0x73, 0x73, 0x5f, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x74, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x17, 0x6c, 0x6f, 0x73, 0x73, 0x4f, 0x6e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x74, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x3b, + 0x0a, 0x1a, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, + 0x69, 0x63, 0x65, 0x5f, 0x61, 0x74, 0x5f, 0x75, 0x70, 0x70, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x17, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, + 0x72, 0x69, 0x63, 0x65, 0x41, 0x74, 0x55, 0x70, 0x70, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x1a, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, + 0x5f, 0x61, 0x74, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x17, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x41, 0x74, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x2a, 0xaa, 0x01, 0x0a, 0x10, 0x4c, 0x65, 0x64, 0x67, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x22, 0x0a, 0x1e, 0x4c, 0x45, 0x44, 0x47, 0x45, 0x52, 0x5f, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x5f, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, @@ -30695,7 +30943,7 @@ var file_data_node_api_v2_trading_data_proto_rawDesc = []byte{ 0x11, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x44, 0x52, 0x41, 0x57, 0x41, 0x4c, 0x53, 0x10, 0x0d, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x53, 0x10, 0x0e, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, - 0x52, 0x45, 0x57, 0x41, 0x52, 0x44, 0x53, 0x10, 0x0f, 0x32, 0xa7, 0x7a, 0x0a, 0x12, 0x54, 0x72, + 0x52, 0x45, 0x57, 0x41, 0x52, 0x44, 0x53, 0x10, 0x0f, 0x32, 0x9e, 0x7b, 0x0a, 0x12, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x61, 0x74, 0x61, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6a, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x24, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, @@ -31662,32 +31910,39 @@ var file_data_node_api_v2_trading_data_proto_rawDesc = []byte{ 0x74, 0x1a, 0x21, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x4d, 0x4d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x09, 0x92, 0x41, 0x06, 0x0a, 0x04, 0x41, 0x4d, 0x4d, 0x73, 0x12, - 0x72, 0x0a, 0x14, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, - 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x2c, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, - 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, - 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, - 0x70, 0x69, 0x2e, 0x48, 0x74, 0x74, 0x70, 0x42, 0x6f, 0x64, 0x79, 0x22, 0x14, 0x92, 0x41, 0x11, - 0x0a, 0x0f, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x30, 0x01, 0x12, 0x4e, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x2e, 0x64, 0x61, - 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x69, - 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x64, 0x61, 0x74, 0x61, - 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x69, 0x6e, 0x67, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x09, 0x92, 0x41, 0x06, 0x0a, 0x04, 0x4d, - 0x69, 0x73, 0x63, 0x42, 0xca, 0x01, 0x5a, 0x31, 0x63, 0x6f, 0x64, 0x65, 0x2e, 0x76, 0x65, 0x67, - 0x61, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x65, 0x67, - 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, 0x93, 0x01, 0x12, 0x22, 0x0a, - 0x13, 0x56, 0x65, 0x67, 0x61, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, - 0x41, 0x50, 0x49, 0x73, 0x32, 0x0b, 0x76, 0x30, 0x2e, 0x37, 0x37, 0x2e, 0x30, 0x2d, 0x64, 0x65, - 0x76, 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, 0x6e, 0x52, 0x39, 0x0a, 0x03, 0x35, 0x30, 0x30, 0x12, 0x32, 0x0a, 0x18, - 0x41, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x14, 0x1a, 0x12, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x75, 0x0a, 0x11, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x41, 0x4d, 0x4d, 0x42, 0x6f, + 0x75, 0x6e, 0x64, 0x73, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x41, + 0x4d, 0x4d, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x2a, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x32, 0x2e, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x41, 0x4d, 0x4d, 0x42, 0x6f, 0x75, + 0x6e, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x09, 0x92, 0x41, 0x06, + 0x0a, 0x04, 0x41, 0x4d, 0x4d, 0x73, 0x12, 0x72, 0x0a, 0x14, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x2c, + 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, + 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x48, 0x74, 0x74, 0x70, 0x42, 0x6f, + 0x64, 0x79, 0x22, 0x14, 0x92, 0x41, 0x11, 0x0a, 0x0f, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, + 0x20, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x30, 0x01, 0x12, 0x4e, 0x0a, 0x04, 0x50, 0x69, + 0x6e, 0x67, 0x12, 0x1c, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1d, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x61, 0x70, 0x69, 0x2e, + 0x76, 0x32, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x09, 0x92, 0x41, 0x06, 0x0a, 0x04, 0x4d, 0x69, 0x73, 0x63, 0x42, 0xca, 0x01, 0x5a, 0x31, 0x63, + 0x6f, 0x64, 0x65, 0x2e, 0x76, 0x65, 0x67, 0x61, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x65, 0x67, 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, 0x93, 0x01, 0x12, 0x22, 0x0a, 0x13, 0x56, 0x65, 0x67, 0x61, 0x20, 0x64, 0x61, 0x74, + 0x61, 0x20, 0x6e, 0x6f, 0x64, 0x65, 0x20, 0x41, 0x50, 0x49, 0x73, 0x32, 0x0b, 0x76, 0x30, 0x2e, + 0x37, 0x37, 0x2e, 0x30, 0x2d, 0x64, 0x65, 0x76, 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, 0x6e, 0x52, 0x39, 0x0a, 0x03, + 0x35, 0x30, 0x30, 0x12, 0x32, 0x0a, 0x18, 0x41, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, + 0x16, 0x0a, 0x14, 0x1a, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -31703,7 +31958,7 @@ func file_data_node_api_v2_trading_data_proto_rawDescGZIP() []byte { } var file_data_node_api_v2_trading_data_proto_enumTypes = make([]protoimpl.EnumInfo, 6) -var file_data_node_api_v2_trading_data_proto_msgTypes = make([]protoimpl.MessageInfo, 427) +var file_data_node_api_v2_trading_data_proto_msgTypes = make([]protoimpl.MessageInfo, 429) var file_data_node_api_v2_trading_data_proto_goTypes = []interface{}{ (LedgerEntryField)(0), // 0: datanode.api.v2.LedgerEntryField (AccountField)(0), // 1: datanode.api.v2.AccountField @@ -32138,107 +32393,109 @@ var file_data_node_api_v2_trading_data_proto_goTypes = []interface{}{ (*ListAMMsResponse)(nil), // 430: datanode.api.v2.ListAMMsResponse (*AMMConnection)(nil), // 431: datanode.api.v2.AMMConnection (*AMMEdge)(nil), // 432: datanode.api.v2.AMMEdge - (*v1.PartyLockedBalance)(nil), // 433: vega.events.v1.PartyLockedBalance - (*v1.PartyVestingBalance)(nil), // 434: vega.events.v1.PartyVestingBalance - (vega.AccountType)(0), // 435: vega.AccountType - (*vega.Order)(nil), // 436: vega.Order - (vega.Order_Status)(0), // 437: vega.Order.Status - (vega.Order_Type)(0), // 438: vega.Order.Type - (vega.Order_TimeInForce)(0), // 439: vega.Order.TimeInForce - (*v1.StopOrderEvent)(nil), // 440: vega.events.v1.StopOrderEvent - (*v1.GameTeamScore)(nil), // 441: vega.events.v1.GameTeamScore - (*v1.GamePartyScore)(nil), // 442: vega.events.v1.GamePartyScore - (vega.StopOrder_Status)(0), // 443: vega.StopOrder.Status - (vega.StopOrder_ExpiryStrategy)(0), // 444: vega.StopOrder.ExpiryStrategy - (*vega.Position)(nil), // 445: vega.Position - (vega.TransferType)(0), // 446: vega.TransferType - (*vega.MarketDepth)(nil), // 447: vega.MarketDepth - (*vega.MarketDepthUpdate)(nil), // 448: vega.MarketDepthUpdate - (*vega.MarketData)(nil), // 449: vega.MarketData - (*vega.PriceLevel)(nil), // 450: vega.PriceLevel - (*vega.Trade)(nil), // 451: vega.Trade - (v1.Transfer_Status)(0), // 452: vega.events.v1.Transfer.Status - (*v1.Transfer)(nil), // 453: vega.events.v1.Transfer - (*v1.TransferFees)(nil), // 454: vega.events.v1.TransferFees - (*vega.NetworkLimits)(nil), // 455: vega.NetworkLimits - (*vega.Vote)(nil), // 456: vega.Vote - (*v1.ERC20MultiSigSignerAdded)(nil), // 457: vega.events.v1.ERC20MultiSigSignerAdded - (*v1.ERC20MultiSigSignerRemoved)(nil), // 458: vega.events.v1.ERC20MultiSigSignerRemoved - (*vega.OracleSpec)(nil), // 459: vega.OracleSpec - (*vega.OracleData)(nil), // 460: vega.OracleData - (*vega.Market)(nil), // 461: vega.Market - (*vega.GovernanceData)(nil), // 462: vega.GovernanceData - (*vega.Party)(nil), // 463: vega.Party - (*vega.PartyProfile)(nil), // 464: vega.PartyProfile - (*vega.MarginLevels)(nil), // 465: vega.MarginLevels - (*vega.Reward)(nil), // 466: vega.Reward - (*vega.RewardSummary)(nil), // 467: vega.RewardSummary - (*vega.EpochRewardSummary)(nil), // 468: vega.EpochRewardSummary - (*vega.Deposit)(nil), // 469: vega.Deposit - (*vega.Withdrawal)(nil), // 470: vega.Withdrawal - (*vega.Asset)(nil), // 471: vega.Asset - (*vega.LiquidityProvision)(nil), // 472: vega.LiquidityProvision - (*vega.LiquidityProviderFeeShare)(nil), // 473: vega.LiquidityProviderFeeShare - (*vega.LiquidityProviderSLA)(nil), // 474: vega.LiquidityProviderSLA - (*v1.PaidLiquidityFeesStats)(nil), // 475: vega.events.v1.PaidLiquidityFeesStats - (vega.Proposal_State)(0), // 476: vega.Proposal.State - (*vega.Delegation)(nil), // 477: vega.Delegation - (vega.NodeStatus)(0), // 478: vega.NodeStatus - (*vega.NodeData)(nil), // 479: vega.NodeData - (*vega.Node)(nil), // 480: vega.Node - (*v11.NodeSignature)(nil), // 481: vega.commands.v1.NodeSignature - (*vega.Epoch)(nil), // 482: vega.Epoch - (*vega.Fee)(nil), // 483: vega.Fee - (vega.Side)(0), // 484: vega.Side - (*vega.NetworkParameter)(nil), // 485: vega.NetworkParameter - (*v1.StakeLinking)(nil), // 486: vega.events.v1.StakeLinking - (*vega.RiskFactor)(nil), // 487: vega.RiskFactor - (v1.BusEventType)(0), // 488: vega.events.v1.BusEventType - (*v1.BusEvent)(nil), // 489: vega.events.v1.BusEvent - (*vega.LedgerMovement)(nil), // 490: vega.LedgerMovement - (*v1.KeyRotation)(nil), // 491: vega.events.v1.KeyRotation - (*v1.EthereumKeyRotation)(nil), // 492: vega.events.v1.EthereumKeyRotation - (v1.ProtocolUpgradeProposalStatus)(0), // 493: vega.events.v1.ProtocolUpgradeProposalStatus - (*v1.ProtocolUpgradeEvent)(nil), // 494: vega.events.v1.ProtocolUpgradeEvent - (*v1.CoreSnapshotData)(nil), // 495: vega.events.v1.CoreSnapshotData - (*vega.Account)(nil), // 496: vega.Account - (*vega.LedgerEntry)(nil), // 497: vega.LedgerEntry - (*vega.Proposal)(nil), // 498: vega.Proposal - (*v1.PartyActivityStreak)(nil), // 499: vega.events.v1.PartyActivityStreak - (*v1.FundingPeriod)(nil), // 500: vega.events.v1.FundingPeriod - (v1.FundingPeriodDataPoint_Source)(0), // 501: vega.events.v1.FundingPeriodDataPoint.Source - (*v1.FundingPeriodDataPoint)(nil), // 502: vega.events.v1.FundingPeriodDataPoint - (vega.MarginMode)(0), // 503: vega.MarginMode - (*vega.BenefitTier)(nil), // 504: vega.BenefitTier - (*vega.StakingTier)(nil), // 505: vega.StakingTier - (*v1.FeesStats)(nil), // 506: vega.events.v1.FeesStats - (*vega.VolumeBenefitTier)(nil), // 507: vega.VolumeBenefitTier - (*v1.TransactionResult)(nil), // 508: vega.events.v1.TransactionResult - (vega.EntityScope)(0), // 509: vega.EntityScope - (vega.DispatchMetric)(0), // 510: vega.DispatchMetric - (v1.AMM_Status)(0), // 511: vega.events.v1.AMM.Status - (*v1.AMM)(nil), // 512: vega.events.v1.AMM - (*httpbody.HttpBody)(nil), // 513: google.api.HttpBody + (*EstimateAMMBoundsRequest)(nil), // 433: datanode.api.v2.EstimateAMMBoundsRequest + (*EstimateAMMBoundsResponse)(nil), // 434: datanode.api.v2.EstimateAMMBoundsResponse + (*v1.PartyLockedBalance)(nil), // 435: vega.events.v1.PartyLockedBalance + (*v1.PartyVestingBalance)(nil), // 436: vega.events.v1.PartyVestingBalance + (vega.AccountType)(0), // 437: vega.AccountType + (*vega.Order)(nil), // 438: vega.Order + (vega.Order_Status)(0), // 439: vega.Order.Status + (vega.Order_Type)(0), // 440: vega.Order.Type + (vega.Order_TimeInForce)(0), // 441: vega.Order.TimeInForce + (*v1.StopOrderEvent)(nil), // 442: vega.events.v1.StopOrderEvent + (*v1.GameTeamScore)(nil), // 443: vega.events.v1.GameTeamScore + (*v1.GamePartyScore)(nil), // 444: vega.events.v1.GamePartyScore + (vega.StopOrder_Status)(0), // 445: vega.StopOrder.Status + (vega.StopOrder_ExpiryStrategy)(0), // 446: vega.StopOrder.ExpiryStrategy + (*vega.Position)(nil), // 447: vega.Position + (vega.TransferType)(0), // 448: vega.TransferType + (*vega.MarketDepth)(nil), // 449: vega.MarketDepth + (*vega.MarketDepthUpdate)(nil), // 450: vega.MarketDepthUpdate + (*vega.MarketData)(nil), // 451: vega.MarketData + (*vega.PriceLevel)(nil), // 452: vega.PriceLevel + (*vega.Trade)(nil), // 453: vega.Trade + (v1.Transfer_Status)(0), // 454: vega.events.v1.Transfer.Status + (*v1.Transfer)(nil), // 455: vega.events.v1.Transfer + (*v1.TransferFees)(nil), // 456: vega.events.v1.TransferFees + (*vega.NetworkLimits)(nil), // 457: vega.NetworkLimits + (*vega.Vote)(nil), // 458: vega.Vote + (*v1.ERC20MultiSigSignerAdded)(nil), // 459: vega.events.v1.ERC20MultiSigSignerAdded + (*v1.ERC20MultiSigSignerRemoved)(nil), // 460: vega.events.v1.ERC20MultiSigSignerRemoved + (*vega.OracleSpec)(nil), // 461: vega.OracleSpec + (*vega.OracleData)(nil), // 462: vega.OracleData + (*vega.Market)(nil), // 463: vega.Market + (*vega.GovernanceData)(nil), // 464: vega.GovernanceData + (*vega.Party)(nil), // 465: vega.Party + (*vega.PartyProfile)(nil), // 466: vega.PartyProfile + (*vega.MarginLevels)(nil), // 467: vega.MarginLevels + (*vega.Reward)(nil), // 468: vega.Reward + (*vega.RewardSummary)(nil), // 469: vega.RewardSummary + (*vega.EpochRewardSummary)(nil), // 470: vega.EpochRewardSummary + (*vega.Deposit)(nil), // 471: vega.Deposit + (*vega.Withdrawal)(nil), // 472: vega.Withdrawal + (*vega.Asset)(nil), // 473: vega.Asset + (*vega.LiquidityProvision)(nil), // 474: vega.LiquidityProvision + (*vega.LiquidityProviderFeeShare)(nil), // 475: vega.LiquidityProviderFeeShare + (*vega.LiquidityProviderSLA)(nil), // 476: vega.LiquidityProviderSLA + (*v1.PaidLiquidityFeesStats)(nil), // 477: vega.events.v1.PaidLiquidityFeesStats + (vega.Proposal_State)(0), // 478: vega.Proposal.State + (*vega.Delegation)(nil), // 479: vega.Delegation + (vega.NodeStatus)(0), // 480: vega.NodeStatus + (*vega.NodeData)(nil), // 481: vega.NodeData + (*vega.Node)(nil), // 482: vega.Node + (*v11.NodeSignature)(nil), // 483: vega.commands.v1.NodeSignature + (*vega.Epoch)(nil), // 484: vega.Epoch + (*vega.Fee)(nil), // 485: vega.Fee + (vega.Side)(0), // 486: vega.Side + (*vega.NetworkParameter)(nil), // 487: vega.NetworkParameter + (*v1.StakeLinking)(nil), // 488: vega.events.v1.StakeLinking + (*vega.RiskFactor)(nil), // 489: vega.RiskFactor + (v1.BusEventType)(0), // 490: vega.events.v1.BusEventType + (*v1.BusEvent)(nil), // 491: vega.events.v1.BusEvent + (*vega.LedgerMovement)(nil), // 492: vega.LedgerMovement + (*v1.KeyRotation)(nil), // 493: vega.events.v1.KeyRotation + (*v1.EthereumKeyRotation)(nil), // 494: vega.events.v1.EthereumKeyRotation + (v1.ProtocolUpgradeProposalStatus)(0), // 495: vega.events.v1.ProtocolUpgradeProposalStatus + (*v1.ProtocolUpgradeEvent)(nil), // 496: vega.events.v1.ProtocolUpgradeEvent + (*v1.CoreSnapshotData)(nil), // 497: vega.events.v1.CoreSnapshotData + (*vega.Account)(nil), // 498: vega.Account + (*vega.LedgerEntry)(nil), // 499: vega.LedgerEntry + (*vega.Proposal)(nil), // 500: vega.Proposal + (*v1.PartyActivityStreak)(nil), // 501: vega.events.v1.PartyActivityStreak + (*v1.FundingPeriod)(nil), // 502: vega.events.v1.FundingPeriod + (v1.FundingPeriodDataPoint_Source)(0), // 503: vega.events.v1.FundingPeriodDataPoint.Source + (*v1.FundingPeriodDataPoint)(nil), // 504: vega.events.v1.FundingPeriodDataPoint + (vega.MarginMode)(0), // 505: vega.MarginMode + (*vega.BenefitTier)(nil), // 506: vega.BenefitTier + (*vega.StakingTier)(nil), // 507: vega.StakingTier + (*v1.FeesStats)(nil), // 508: vega.events.v1.FeesStats + (*vega.VolumeBenefitTier)(nil), // 509: vega.VolumeBenefitTier + (*v1.TransactionResult)(nil), // 510: vega.events.v1.TransactionResult + (vega.EntityScope)(0), // 511: vega.EntityScope + (vega.DispatchMetric)(0), // 512: vega.DispatchMetric + (v1.AMM_Status)(0), // 513: vega.events.v1.AMM.Status + (*v1.AMM)(nil), // 514: vega.events.v1.AMM + (*httpbody.HttpBody)(nil), // 515: google.api.HttpBody } var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ - 433, // 0: datanode.api.v2.GetVestingBalancesSummaryResponse.locked_balances:type_name -> vega.events.v1.PartyLockedBalance - 434, // 1: datanode.api.v2.GetVestingBalancesSummaryResponse.vesting_balances:type_name -> vega.events.v1.PartyVestingBalance - 435, // 2: datanode.api.v2.AccountBalance.type:type_name -> vega.AccountType + 435, // 0: datanode.api.v2.GetVestingBalancesSummaryResponse.locked_balances:type_name -> vega.events.v1.PartyLockedBalance + 436, // 1: datanode.api.v2.GetVestingBalancesSummaryResponse.vesting_balances:type_name -> vega.events.v1.PartyVestingBalance + 437, // 2: datanode.api.v2.AccountBalance.type:type_name -> vega.AccountType 75, // 3: datanode.api.v2.ListAccountsRequest.filter:type_name -> datanode.api.v2.AccountFilter 6, // 4: datanode.api.v2.ListAccountsRequest.pagination:type_name -> datanode.api.v2.Pagination 15, // 5: datanode.api.v2.ListAccountsResponse.accounts:type_name -> datanode.api.v2.AccountsConnection 16, // 6: datanode.api.v2.AccountsConnection.edges:type_name -> datanode.api.v2.AccountEdge 7, // 7: datanode.api.v2.AccountsConnection.page_info:type_name -> datanode.api.v2.PageInfo 12, // 8: datanode.api.v2.AccountEdge.node:type_name -> datanode.api.v2.AccountBalance - 435, // 9: datanode.api.v2.ObserveAccountsRequest.type:type_name -> vega.AccountType + 437, // 9: datanode.api.v2.ObserveAccountsRequest.type:type_name -> vega.AccountType 19, // 10: datanode.api.v2.ObserveAccountsResponse.snapshot:type_name -> datanode.api.v2.AccountSnapshotPage 20, // 11: datanode.api.v2.ObserveAccountsResponse.updates:type_name -> datanode.api.v2.AccountUpdates 12, // 12: datanode.api.v2.AccountSnapshotPage.accounts:type_name -> datanode.api.v2.AccountBalance 12, // 13: datanode.api.v2.AccountUpdates.accounts:type_name -> datanode.api.v2.AccountBalance - 436, // 14: datanode.api.v2.GetOrderResponse.order:type_name -> vega.Order - 437, // 15: datanode.api.v2.OrderFilter.statuses:type_name -> vega.Order.Status - 438, // 16: datanode.api.v2.OrderFilter.types:type_name -> vega.Order.Type - 439, // 17: datanode.api.v2.OrderFilter.time_in_forces:type_name -> vega.Order.TimeInForce + 438, // 14: datanode.api.v2.GetOrderResponse.order:type_name -> vega.Order + 439, // 15: datanode.api.v2.OrderFilter.statuses:type_name -> vega.Order.Status + 440, // 16: datanode.api.v2.OrderFilter.types:type_name -> vega.Order.Type + 441, // 17: datanode.api.v2.OrderFilter.time_in_forces:type_name -> vega.Order.TimeInForce 298, // 18: datanode.api.v2.OrderFilter.date_range:type_name -> datanode.api.v2.DateRange 6, // 19: datanode.api.v2.ListOrdersRequest.pagination:type_name -> datanode.api.v2.Pagination 25, // 20: datanode.api.v2.ListOrdersRequest.filter:type_name -> datanode.api.v2.OrderFilter @@ -32247,27 +32504,27 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 180, // 23: datanode.api.v2.ListOrderVersionsResponse.orders:type_name -> datanode.api.v2.OrderConnection 32, // 24: datanode.api.v2.ObserveOrdersResponse.snapshot:type_name -> datanode.api.v2.OrderSnapshotPage 33, // 25: datanode.api.v2.ObserveOrdersResponse.updates:type_name -> datanode.api.v2.OrderUpdates - 436, // 26: datanode.api.v2.OrderSnapshotPage.orders:type_name -> vega.Order - 436, // 27: datanode.api.v2.OrderUpdates.orders:type_name -> vega.Order - 440, // 28: datanode.api.v2.GetStopOrderResponse.order:type_name -> vega.events.v1.StopOrderEvent + 438, // 26: datanode.api.v2.OrderSnapshotPage.orders:type_name -> vega.Order + 438, // 27: datanode.api.v2.OrderUpdates.orders:type_name -> vega.Order + 442, // 28: datanode.api.v2.GetStopOrderResponse.order:type_name -> vega.events.v1.StopOrderEvent 6, // 29: datanode.api.v2.ListGameTeamScoresRequest.pagination:type_name -> datanode.api.v2.Pagination 37, // 30: datanode.api.v2.ListGameTeamScoresRequest.filter:type_name -> datanode.api.v2.GameTeamScoresFilter 39, // 31: datanode.api.v2.ListGameTeamScoresResponse.team_scores:type_name -> datanode.api.v2.GameTeamScoresConnection 40, // 32: datanode.api.v2.GameTeamScoresConnection.edges:type_name -> datanode.api.v2.GameTeamScoresEdge 7, // 33: datanode.api.v2.GameTeamScoresConnection.page_info:type_name -> datanode.api.v2.PageInfo - 441, // 34: datanode.api.v2.GameTeamScoresEdge.node:type_name -> vega.events.v1.GameTeamScore + 443, // 34: datanode.api.v2.GameTeamScoresEdge.node:type_name -> vega.events.v1.GameTeamScore 6, // 35: datanode.api.v2.ListGamePartyScoresRequest.pagination:type_name -> datanode.api.v2.Pagination 42, // 36: datanode.api.v2.ListGamePartyScoresRequest.filter:type_name -> datanode.api.v2.GamePartyScoresFilter 44, // 37: datanode.api.v2.ListGamePartyScoresResponse.party_scores:type_name -> datanode.api.v2.GamePartyScoresConnection 45, // 38: datanode.api.v2.GamePartyScoresConnection.edges:type_name -> datanode.api.v2.GamePartyScoresEdge 7, // 39: datanode.api.v2.GamePartyScoresConnection.page_info:type_name -> datanode.api.v2.PageInfo - 442, // 40: datanode.api.v2.GamePartyScoresEdge.node:type_name -> vega.events.v1.GamePartyScore + 444, // 40: datanode.api.v2.GamePartyScoresEdge.node:type_name -> vega.events.v1.GamePartyScore 6, // 41: datanode.api.v2.ListStopOrdersRequest.pagination:type_name -> datanode.api.v2.Pagination 47, // 42: datanode.api.v2.ListStopOrdersRequest.filter:type_name -> datanode.api.v2.StopOrderFilter - 443, // 43: datanode.api.v2.StopOrderFilter.statuses:type_name -> vega.StopOrder.Status - 444, // 44: datanode.api.v2.StopOrderFilter.expiry_strategies:type_name -> vega.StopOrder.ExpiryStrategy + 445, // 43: datanode.api.v2.StopOrderFilter.statuses:type_name -> vega.StopOrder.Status + 446, // 44: datanode.api.v2.StopOrderFilter.expiry_strategies:type_name -> vega.StopOrder.ExpiryStrategy 298, // 45: datanode.api.v2.StopOrderFilter.date_range:type_name -> datanode.api.v2.DateRange - 440, // 46: datanode.api.v2.StopOrderEdge.node:type_name -> vega.events.v1.StopOrderEvent + 442, // 46: datanode.api.v2.StopOrderEdge.node:type_name -> vega.events.v1.StopOrderEvent 48, // 47: datanode.api.v2.StopOrderConnection.edges:type_name -> datanode.api.v2.StopOrderEdge 7, // 48: datanode.api.v2.StopOrderConnection.page_info:type_name -> datanode.api.v2.PageInfo 49, // 49: datanode.api.v2.ListStopOrdersResponse.orders:type_name -> datanode.api.v2.StopOrderConnection @@ -32276,19 +32533,19 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 53, // 52: datanode.api.v2.ListAllPositionsRequest.filter:type_name -> datanode.api.v2.PositionsFilter 6, // 53: datanode.api.v2.ListAllPositionsRequest.pagination:type_name -> datanode.api.v2.Pagination 57, // 54: datanode.api.v2.ListAllPositionsResponse.positions:type_name -> datanode.api.v2.PositionConnection - 445, // 55: datanode.api.v2.PositionEdge.node:type_name -> vega.Position + 447, // 55: datanode.api.v2.PositionEdge.node:type_name -> vega.Position 56, // 56: datanode.api.v2.PositionConnection.edges:type_name -> datanode.api.v2.PositionEdge 7, // 57: datanode.api.v2.PositionConnection.page_info:type_name -> datanode.api.v2.PageInfo 60, // 58: datanode.api.v2.ObservePositionsResponse.snapshot:type_name -> datanode.api.v2.PositionSnapshotPage 61, // 59: datanode.api.v2.ObservePositionsResponse.updates:type_name -> datanode.api.v2.PositionUpdates - 445, // 60: datanode.api.v2.PositionSnapshotPage.positions:type_name -> vega.Position - 445, // 61: datanode.api.v2.PositionUpdates.positions:type_name -> vega.Position + 447, // 60: datanode.api.v2.PositionSnapshotPage.positions:type_name -> vega.Position + 447, // 61: datanode.api.v2.PositionUpdates.positions:type_name -> vega.Position 75, // 62: datanode.api.v2.LedgerEntryFilter.from_account_filter:type_name -> datanode.api.v2.AccountFilter 75, // 63: datanode.api.v2.LedgerEntryFilter.to_account_filter:type_name -> datanode.api.v2.AccountFilter - 446, // 64: datanode.api.v2.LedgerEntryFilter.transfer_types:type_name -> vega.TransferType - 446, // 65: datanode.api.v2.AggregatedLedgerEntry.transfer_type:type_name -> vega.TransferType - 435, // 66: datanode.api.v2.AggregatedLedgerEntry.from_account_type:type_name -> vega.AccountType - 435, // 67: datanode.api.v2.AggregatedLedgerEntry.to_account_type:type_name -> vega.AccountType + 448, // 64: datanode.api.v2.LedgerEntryFilter.transfer_types:type_name -> vega.TransferType + 448, // 65: datanode.api.v2.AggregatedLedgerEntry.transfer_type:type_name -> vega.TransferType + 437, // 66: datanode.api.v2.AggregatedLedgerEntry.from_account_type:type_name -> vega.AccountType + 437, // 67: datanode.api.v2.AggregatedLedgerEntry.to_account_type:type_name -> vega.AccountType 62, // 68: datanode.api.v2.ListLedgerEntriesRequest.filter:type_name -> datanode.api.v2.LedgerEntryFilter 6, // 69: datanode.api.v2.ListLedgerEntriesRequest.pagination:type_name -> datanode.api.v2.Pagination 298, // 70: datanode.api.v2.ListLedgerEntriesRequest.date_range:type_name -> datanode.api.v2.DateRange @@ -32309,35 +32566,35 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 76, // 85: datanode.api.v2.AggregatedBalanceEdge.node:type_name -> datanode.api.v2.AggregatedBalance 73, // 86: datanode.api.v2.AggregatedBalanceConnection.edges:type_name -> datanode.api.v2.AggregatedBalanceEdge 7, // 87: datanode.api.v2.AggregatedBalanceConnection.page_info:type_name -> datanode.api.v2.PageInfo - 435, // 88: datanode.api.v2.AccountFilter.account_types:type_name -> vega.AccountType - 435, // 89: datanode.api.v2.AggregatedBalance.account_type:type_name -> vega.AccountType - 447, // 90: datanode.api.v2.ObserveMarketsDepthResponse.market_depth:type_name -> vega.MarketDepth - 448, // 91: datanode.api.v2.ObserveMarketsDepthUpdatesResponse.update:type_name -> vega.MarketDepthUpdate - 449, // 92: datanode.api.v2.ObserveMarketsDataResponse.market_data:type_name -> vega.MarketData - 450, // 93: datanode.api.v2.GetLatestMarketDepthResponse.buy:type_name -> vega.PriceLevel - 450, // 94: datanode.api.v2.GetLatestMarketDepthResponse.sell:type_name -> vega.PriceLevel - 451, // 95: datanode.api.v2.GetLatestMarketDepthResponse.last_trade:type_name -> vega.Trade - 449, // 96: datanode.api.v2.ListLatestMarketDataResponse.markets_data:type_name -> vega.MarketData - 449, // 97: datanode.api.v2.GetLatestMarketDataResponse.market_data:type_name -> vega.MarketData + 437, // 88: datanode.api.v2.AccountFilter.account_types:type_name -> vega.AccountType + 437, // 89: datanode.api.v2.AggregatedBalance.account_type:type_name -> vega.AccountType + 449, // 90: datanode.api.v2.ObserveMarketsDepthResponse.market_depth:type_name -> vega.MarketDepth + 450, // 91: datanode.api.v2.ObserveMarketsDepthUpdatesResponse.update:type_name -> vega.MarketDepthUpdate + 451, // 92: datanode.api.v2.ObserveMarketsDataResponse.market_data:type_name -> vega.MarketData + 452, // 93: datanode.api.v2.GetLatestMarketDepthResponse.buy:type_name -> vega.PriceLevel + 452, // 94: datanode.api.v2.GetLatestMarketDepthResponse.sell:type_name -> vega.PriceLevel + 453, // 95: datanode.api.v2.GetLatestMarketDepthResponse.last_trade:type_name -> vega.Trade + 451, // 96: datanode.api.v2.ListLatestMarketDataResponse.markets_data:type_name -> vega.MarketData + 451, // 97: datanode.api.v2.GetLatestMarketDataResponse.market_data:type_name -> vega.MarketData 6, // 98: datanode.api.v2.GetMarketDataHistoryByIDRequest.pagination:type_name -> datanode.api.v2.Pagination 92, // 99: datanode.api.v2.GetMarketDataHistoryByIDResponse.market_data:type_name -> datanode.api.v2.MarketDataConnection - 449, // 100: datanode.api.v2.MarketDataEdge.node:type_name -> vega.MarketData + 451, // 100: datanode.api.v2.MarketDataEdge.node:type_name -> vega.MarketData 91, // 101: datanode.api.v2.MarketDataConnection.edges:type_name -> datanode.api.v2.MarketDataEdge 7, // 102: datanode.api.v2.MarketDataConnection.page_info:type_name -> datanode.api.v2.PageInfo 2, // 103: datanode.api.v2.ListTransfersRequest.direction:type_name -> datanode.api.v2.TransferDirection 6, // 104: datanode.api.v2.ListTransfersRequest.pagination:type_name -> datanode.api.v2.Pagination - 452, // 105: datanode.api.v2.ListTransfersRequest.status:type_name -> vega.events.v1.Transfer.Status + 454, // 105: datanode.api.v2.ListTransfersRequest.status:type_name -> vega.events.v1.Transfer.Status 4, // 106: datanode.api.v2.ListTransfersRequest.scope:type_name -> datanode.api.v2.ListTransfersRequest.Scope - 435, // 107: datanode.api.v2.ListTransfersRequest.from_account_type:type_name -> vega.AccountType - 435, // 108: datanode.api.v2.ListTransfersRequest.to_account_type:type_name -> vega.AccountType + 437, // 107: datanode.api.v2.ListTransfersRequest.from_account_type:type_name -> vega.AccountType + 437, // 108: datanode.api.v2.ListTransfersRequest.to_account_type:type_name -> vega.AccountType 97, // 109: datanode.api.v2.ListTransfersResponse.transfers:type_name -> datanode.api.v2.TransferConnection - 453, // 110: datanode.api.v2.TransferNode.transfer:type_name -> vega.events.v1.Transfer - 454, // 111: datanode.api.v2.TransferNode.fees:type_name -> vega.events.v1.TransferFees + 455, // 110: datanode.api.v2.TransferNode.transfer:type_name -> vega.events.v1.Transfer + 456, // 111: datanode.api.v2.TransferNode.fees:type_name -> vega.events.v1.TransferFees 95, // 112: datanode.api.v2.TransferEdge.node:type_name -> datanode.api.v2.TransferNode 96, // 113: datanode.api.v2.TransferConnection.edges:type_name -> datanode.api.v2.TransferEdge 7, // 114: datanode.api.v2.TransferConnection.page_info:type_name -> datanode.api.v2.PageInfo 95, // 115: datanode.api.v2.GetTransferResponse.transfer_node:type_name -> datanode.api.v2.TransferNode - 455, // 116: datanode.api.v2.GetNetworkLimitsResponse.limits:type_name -> vega.NetworkLimits + 457, // 116: datanode.api.v2.GetNetworkLimitsResponse.limits:type_name -> vega.NetworkLimits 103, // 117: datanode.api.v2.ListCandleIntervalsResponse.interval_to_candle_id:type_name -> datanode.api.v2.IntervalToCandleId 105, // 118: datanode.api.v2.ObserveCandleDataResponse.candle:type_name -> datanode.api.v2.Candle 6, // 119: datanode.api.v2.ListCandleDataRequest.pagination:type_name -> datanode.api.v2.Pagination @@ -32347,170 +32604,170 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 7, // 123: datanode.api.v2.CandleDataConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 124: datanode.api.v2.ListVotesRequest.pagination:type_name -> datanode.api.v2.Pagination 115, // 125: datanode.api.v2.ListVotesResponse.votes:type_name -> datanode.api.v2.VoteConnection - 456, // 126: datanode.api.v2.VoteEdge.node:type_name -> vega.Vote + 458, // 126: datanode.api.v2.VoteEdge.node:type_name -> vega.Vote 114, // 127: datanode.api.v2.VoteConnection.edges:type_name -> datanode.api.v2.VoteEdge 7, // 128: datanode.api.v2.VoteConnection.page_info:type_name -> datanode.api.v2.PageInfo - 456, // 129: datanode.api.v2.ObserveVotesResponse.vote:type_name -> vega.Vote + 458, // 129: datanode.api.v2.ObserveVotesResponse.vote:type_name -> vega.Vote 6, // 130: datanode.api.v2.ListERC20MultiSigSignerAddedBundlesRequest.pagination:type_name -> datanode.api.v2.Pagination 122, // 131: datanode.api.v2.ListERC20MultiSigSignerAddedBundlesResponse.bundles:type_name -> datanode.api.v2.ERC20MultiSigSignerAddedConnection - 457, // 132: datanode.api.v2.ERC20MultiSigSignerAddedEdge.node:type_name -> vega.events.v1.ERC20MultiSigSignerAdded + 459, // 132: datanode.api.v2.ERC20MultiSigSignerAddedEdge.node:type_name -> vega.events.v1.ERC20MultiSigSignerAdded 123, // 133: datanode.api.v2.ERC20MultiSigSignerAddedBundleEdge.node:type_name -> datanode.api.v2.ERC20MultiSigSignerAddedBundle 121, // 134: datanode.api.v2.ERC20MultiSigSignerAddedConnection.edges:type_name -> datanode.api.v2.ERC20MultiSigSignerAddedBundleEdge 7, // 135: datanode.api.v2.ERC20MultiSigSignerAddedConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 136: datanode.api.v2.ListERC20MultiSigSignerRemovedBundlesRequest.pagination:type_name -> datanode.api.v2.Pagination 128, // 137: datanode.api.v2.ListERC20MultiSigSignerRemovedBundlesResponse.bundles:type_name -> datanode.api.v2.ERC20MultiSigSignerRemovedConnection - 458, // 138: datanode.api.v2.ERC20MultiSigSignerRemovedEdge.node:type_name -> vega.events.v1.ERC20MultiSigSignerRemoved + 460, // 138: datanode.api.v2.ERC20MultiSigSignerRemovedEdge.node:type_name -> vega.events.v1.ERC20MultiSigSignerRemoved 129, // 139: datanode.api.v2.ERC20MultiSigSignerRemovedBundleEdge.node:type_name -> datanode.api.v2.ERC20MultiSigSignerRemovedBundle 127, // 140: datanode.api.v2.ERC20MultiSigSignerRemovedConnection.edges:type_name -> datanode.api.v2.ERC20MultiSigSignerRemovedBundleEdge 7, // 141: datanode.api.v2.ERC20MultiSigSignerRemovedConnection.page_info:type_name -> datanode.api.v2.PageInfo - 451, // 142: datanode.api.v2.GetLastTradeResponse.trade:type_name -> vega.Trade + 453, // 142: datanode.api.v2.GetLastTradeResponse.trade:type_name -> vega.Trade 6, // 143: datanode.api.v2.ListTradesRequest.pagination:type_name -> datanode.api.v2.Pagination 298, // 144: datanode.api.v2.ListTradesRequest.date_range:type_name -> datanode.api.v2.DateRange 140, // 145: datanode.api.v2.ListTradesResponse.trades:type_name -> datanode.api.v2.TradeConnection 141, // 146: datanode.api.v2.TradeConnection.edges:type_name -> datanode.api.v2.TradeEdge 7, // 147: datanode.api.v2.TradeConnection.page_info:type_name -> datanode.api.v2.PageInfo - 451, // 148: datanode.api.v2.TradeEdge.node:type_name -> vega.Trade - 451, // 149: datanode.api.v2.ObserveTradesResponse.trades:type_name -> vega.Trade - 459, // 150: datanode.api.v2.GetOracleSpecResponse.oracle_spec:type_name -> vega.OracleSpec + 453, // 148: datanode.api.v2.TradeEdge.node:type_name -> vega.Trade + 453, // 149: datanode.api.v2.ObserveTradesResponse.trades:type_name -> vega.Trade + 461, // 150: datanode.api.v2.GetOracleSpecResponse.oracle_spec:type_name -> vega.OracleSpec 6, // 151: datanode.api.v2.ListOracleSpecsRequest.pagination:type_name -> datanode.api.v2.Pagination 151, // 152: datanode.api.v2.ListOracleSpecsResponse.oracle_specs:type_name -> datanode.api.v2.OracleSpecsConnection 6, // 153: datanode.api.v2.ListOracleDataRequest.pagination:type_name -> datanode.api.v2.Pagination 153, // 154: datanode.api.v2.ListOracleDataResponse.oracle_data:type_name -> datanode.api.v2.OracleDataConnection - 459, // 155: datanode.api.v2.OracleSpecEdge.node:type_name -> vega.OracleSpec + 461, // 155: datanode.api.v2.OracleSpecEdge.node:type_name -> vega.OracleSpec 150, // 156: datanode.api.v2.OracleSpecsConnection.edges:type_name -> datanode.api.v2.OracleSpecEdge 7, // 157: datanode.api.v2.OracleSpecsConnection.page_info:type_name -> datanode.api.v2.PageInfo - 460, // 158: datanode.api.v2.OracleDataEdge.node:type_name -> vega.OracleData + 462, // 158: datanode.api.v2.OracleDataEdge.node:type_name -> vega.OracleData 152, // 159: datanode.api.v2.OracleDataConnection.edges:type_name -> datanode.api.v2.OracleDataEdge 7, // 160: datanode.api.v2.OracleDataConnection.page_info:type_name -> datanode.api.v2.PageInfo - 461, // 161: datanode.api.v2.GetMarketResponse.market:type_name -> vega.Market + 463, // 161: datanode.api.v2.GetMarketResponse.market:type_name -> vega.Market 6, // 162: datanode.api.v2.ListMarketsRequest.pagination:type_name -> datanode.api.v2.Pagination 159, // 163: datanode.api.v2.ListMarketsResponse.markets:type_name -> datanode.api.v2.MarketConnection - 461, // 164: datanode.api.v2.MarketEdge.node:type_name -> vega.Market + 463, // 164: datanode.api.v2.MarketEdge.node:type_name -> vega.Market 158, // 165: datanode.api.v2.MarketConnection.edges:type_name -> datanode.api.v2.MarketEdge 7, // 166: datanode.api.v2.MarketConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 167: datanode.api.v2.ListSuccessorMarketsRequest.pagination:type_name -> datanode.api.v2.Pagination - 461, // 168: datanode.api.v2.SuccessorMarket.market:type_name -> vega.Market - 462, // 169: datanode.api.v2.SuccessorMarket.proposals:type_name -> vega.GovernanceData + 463, // 168: datanode.api.v2.SuccessorMarket.market:type_name -> vega.Market + 464, // 169: datanode.api.v2.SuccessorMarket.proposals:type_name -> vega.GovernanceData 161, // 170: datanode.api.v2.SuccessorMarketEdge.node:type_name -> datanode.api.v2.SuccessorMarket 162, // 171: datanode.api.v2.SuccessorMarketConnection.edges:type_name -> datanode.api.v2.SuccessorMarketEdge 7, // 172: datanode.api.v2.SuccessorMarketConnection.page_info:type_name -> datanode.api.v2.PageInfo 163, // 173: datanode.api.v2.ListSuccessorMarketsResponse.successor_markets:type_name -> datanode.api.v2.SuccessorMarketConnection - 463, // 174: datanode.api.v2.GetPartyResponse.party:type_name -> vega.Party + 465, // 174: datanode.api.v2.GetPartyResponse.party:type_name -> vega.Party 6, // 175: datanode.api.v2.ListPartiesRequest.pagination:type_name -> datanode.api.v2.Pagination 170, // 176: datanode.api.v2.ListPartiesResponse.parties:type_name -> datanode.api.v2.PartyConnection - 463, // 177: datanode.api.v2.PartyEdge.node:type_name -> vega.Party + 465, // 177: datanode.api.v2.PartyEdge.node:type_name -> vega.Party 169, // 178: datanode.api.v2.PartyConnection.edges:type_name -> datanode.api.v2.PartyEdge 7, // 179: datanode.api.v2.PartyConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 180: datanode.api.v2.ListPartiesProfilesRequest.pagination:type_name -> datanode.api.v2.Pagination 174, // 181: datanode.api.v2.ListPartiesProfilesResponse.profiles:type_name -> datanode.api.v2.PartiesProfilesConnection - 464, // 182: datanode.api.v2.PartyProfileEdge.node:type_name -> vega.PartyProfile + 466, // 182: datanode.api.v2.PartyProfileEdge.node:type_name -> vega.PartyProfile 173, // 183: datanode.api.v2.PartiesProfilesConnection.edges:type_name -> datanode.api.v2.PartyProfileEdge 7, // 184: datanode.api.v2.PartiesProfilesConnection.page_info:type_name -> datanode.api.v2.PageInfo - 436, // 185: datanode.api.v2.OrderEdge.node:type_name -> vega.Order + 438, // 185: datanode.api.v2.OrderEdge.node:type_name -> vega.Order 6, // 186: datanode.api.v2.ListMarginLevelsRequest.pagination:type_name -> datanode.api.v2.Pagination 182, // 187: datanode.api.v2.ListMarginLevelsResponse.margin_levels:type_name -> datanode.api.v2.MarginConnection - 465, // 188: datanode.api.v2.ObserveMarginLevelsResponse.margin_levels:type_name -> vega.MarginLevels + 467, // 188: datanode.api.v2.ObserveMarginLevelsResponse.margin_levels:type_name -> vega.MarginLevels 175, // 189: datanode.api.v2.OrderConnection.edges:type_name -> datanode.api.v2.OrderEdge 7, // 190: datanode.api.v2.OrderConnection.page_info:type_name -> datanode.api.v2.PageInfo - 465, // 191: datanode.api.v2.MarginEdge.node:type_name -> vega.MarginLevels + 467, // 191: datanode.api.v2.MarginEdge.node:type_name -> vega.MarginLevels 181, // 192: datanode.api.v2.MarginConnection.edges:type_name -> datanode.api.v2.MarginEdge 7, // 193: datanode.api.v2.MarginConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 194: datanode.api.v2.ListRewardsRequest.pagination:type_name -> datanode.api.v2.Pagination 186, // 195: datanode.api.v2.ListRewardsResponse.rewards:type_name -> datanode.api.v2.RewardsConnection - 466, // 196: datanode.api.v2.RewardEdge.node:type_name -> vega.Reward + 468, // 196: datanode.api.v2.RewardEdge.node:type_name -> vega.Reward 185, // 197: datanode.api.v2.RewardsConnection.edges:type_name -> datanode.api.v2.RewardEdge 7, // 198: datanode.api.v2.RewardsConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 199: datanode.api.v2.ListRewardSummariesRequest.pagination:type_name -> datanode.api.v2.Pagination - 467, // 200: datanode.api.v2.ListRewardSummariesResponse.summaries:type_name -> vega.RewardSummary + 469, // 200: datanode.api.v2.ListRewardSummariesResponse.summaries:type_name -> vega.RewardSummary 189, // 201: datanode.api.v2.ListEpochRewardSummariesRequest.filter:type_name -> datanode.api.v2.RewardSummaryFilter 6, // 202: datanode.api.v2.ListEpochRewardSummariesRequest.pagination:type_name -> datanode.api.v2.Pagination 192, // 203: datanode.api.v2.ListEpochRewardSummariesResponse.summaries:type_name -> datanode.api.v2.EpochRewardSummaryConnection 193, // 204: datanode.api.v2.EpochRewardSummaryConnection.edges:type_name -> datanode.api.v2.EpochRewardSummaryEdge 7, // 205: datanode.api.v2.EpochRewardSummaryConnection.page_info:type_name -> datanode.api.v2.PageInfo - 468, // 206: datanode.api.v2.EpochRewardSummaryEdge.node:type_name -> vega.EpochRewardSummary - 466, // 207: datanode.api.v2.ObserveRewardsResponse.reward:type_name -> vega.Reward - 469, // 208: datanode.api.v2.GetDepositResponse.deposit:type_name -> vega.Deposit + 470, // 206: datanode.api.v2.EpochRewardSummaryEdge.node:type_name -> vega.EpochRewardSummary + 468, // 207: datanode.api.v2.ObserveRewardsResponse.reward:type_name -> vega.Reward + 471, // 208: datanode.api.v2.GetDepositResponse.deposit:type_name -> vega.Deposit 6, // 209: datanode.api.v2.ListDepositsRequest.pagination:type_name -> datanode.api.v2.Pagination 298, // 210: datanode.api.v2.ListDepositsRequest.date_range:type_name -> datanode.api.v2.DateRange 201, // 211: datanode.api.v2.ListDepositsResponse.deposits:type_name -> datanode.api.v2.DepositsConnection - 469, // 212: datanode.api.v2.DepositEdge.node:type_name -> vega.Deposit + 471, // 212: datanode.api.v2.DepositEdge.node:type_name -> vega.Deposit 200, // 213: datanode.api.v2.DepositsConnection.edges:type_name -> datanode.api.v2.DepositEdge 7, // 214: datanode.api.v2.DepositsConnection.page_info:type_name -> datanode.api.v2.PageInfo - 470, // 215: datanode.api.v2.GetWithdrawalResponse.withdrawal:type_name -> vega.Withdrawal + 472, // 215: datanode.api.v2.GetWithdrawalResponse.withdrawal:type_name -> vega.Withdrawal 6, // 216: datanode.api.v2.ListWithdrawalsRequest.pagination:type_name -> datanode.api.v2.Pagination 298, // 217: datanode.api.v2.ListWithdrawalsRequest.date_range:type_name -> datanode.api.v2.DateRange 207, // 218: datanode.api.v2.ListWithdrawalsResponse.withdrawals:type_name -> datanode.api.v2.WithdrawalsConnection - 470, // 219: datanode.api.v2.WithdrawalEdge.node:type_name -> vega.Withdrawal + 472, // 219: datanode.api.v2.WithdrawalEdge.node:type_name -> vega.Withdrawal 206, // 220: datanode.api.v2.WithdrawalsConnection.edges:type_name -> datanode.api.v2.WithdrawalEdge 7, // 221: datanode.api.v2.WithdrawalsConnection.page_info:type_name -> datanode.api.v2.PageInfo - 471, // 222: datanode.api.v2.GetAssetResponse.asset:type_name -> vega.Asset + 473, // 222: datanode.api.v2.GetAssetResponse.asset:type_name -> vega.Asset 6, // 223: datanode.api.v2.ListAssetsRequest.pagination:type_name -> datanode.api.v2.Pagination 213, // 224: datanode.api.v2.ListAssetsResponse.assets:type_name -> datanode.api.v2.AssetsConnection - 471, // 225: datanode.api.v2.AssetEdge.node:type_name -> vega.Asset + 473, // 225: datanode.api.v2.AssetEdge.node:type_name -> vega.Asset 212, // 226: datanode.api.v2.AssetsConnection.edges:type_name -> datanode.api.v2.AssetEdge 7, // 227: datanode.api.v2.AssetsConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 228: datanode.api.v2.ListLiquidityProvisionsRequest.pagination:type_name -> datanode.api.v2.Pagination 6, // 229: datanode.api.v2.ListAllLiquidityProvisionsRequest.pagination:type_name -> datanode.api.v2.Pagination 221, // 230: datanode.api.v2.ListLiquidityProvisionsResponse.liquidity_provisions:type_name -> datanode.api.v2.LiquidityProvisionsConnection 222, // 231: datanode.api.v2.ListAllLiquidityProvisionsResponse.liquidity_provisions:type_name -> datanode.api.v2.LiquidityProvisionsWithPendingConnection - 472, // 232: datanode.api.v2.LiquidityProvision.current:type_name -> vega.LiquidityProvision - 472, // 233: datanode.api.v2.LiquidityProvision.pending:type_name -> vega.LiquidityProvision - 472, // 234: datanode.api.v2.LiquidityProvisionsEdge.node:type_name -> vega.LiquidityProvision + 474, // 232: datanode.api.v2.LiquidityProvision.current:type_name -> vega.LiquidityProvision + 474, // 233: datanode.api.v2.LiquidityProvision.pending:type_name -> vega.LiquidityProvision + 474, // 234: datanode.api.v2.LiquidityProvisionsEdge.node:type_name -> vega.LiquidityProvision 218, // 235: datanode.api.v2.LiquidityProvisionWithPendingEdge.node:type_name -> datanode.api.v2.LiquidityProvision 219, // 236: datanode.api.v2.LiquidityProvisionsConnection.edges:type_name -> datanode.api.v2.LiquidityProvisionsEdge 7, // 237: datanode.api.v2.LiquidityProvisionsConnection.page_info:type_name -> datanode.api.v2.PageInfo 220, // 238: datanode.api.v2.LiquidityProvisionsWithPendingConnection.edges:type_name -> datanode.api.v2.LiquidityProvisionWithPendingEdge 7, // 239: datanode.api.v2.LiquidityProvisionsWithPendingConnection.page_info:type_name -> datanode.api.v2.PageInfo - 472, // 240: datanode.api.v2.ObserveLiquidityProvisionsResponse.liquidity_provisions:type_name -> vega.LiquidityProvision + 474, // 240: datanode.api.v2.ObserveLiquidityProvisionsResponse.liquidity_provisions:type_name -> vega.LiquidityProvision 6, // 241: datanode.api.v2.ListLiquidityProvidersRequest.pagination:type_name -> datanode.api.v2.Pagination - 473, // 242: datanode.api.v2.LiquidityProvider.fee_share:type_name -> vega.LiquidityProviderFeeShare - 474, // 243: datanode.api.v2.LiquidityProvider.sla:type_name -> vega.LiquidityProviderSLA + 475, // 242: datanode.api.v2.LiquidityProvider.fee_share:type_name -> vega.LiquidityProviderFeeShare + 476, // 243: datanode.api.v2.LiquidityProvider.sla:type_name -> vega.LiquidityProviderSLA 226, // 244: datanode.api.v2.LiquidityProviderEdge.node:type_name -> datanode.api.v2.LiquidityProvider 227, // 245: datanode.api.v2.LiquidityProviderConnection.edges:type_name -> datanode.api.v2.LiquidityProviderEdge 7, // 246: datanode.api.v2.LiquidityProviderConnection.page_info:type_name -> datanode.api.v2.PageInfo 228, // 247: datanode.api.v2.ListLiquidityProvidersResponse.liquidity_providers:type_name -> datanode.api.v2.LiquidityProviderConnection 6, // 248: datanode.api.v2.ListPaidLiquidityFeesRequest.pagination:type_name -> datanode.api.v2.Pagination 233, // 249: datanode.api.v2.ListPaidLiquidityFeesResponse.paid_liquidity_fees:type_name -> datanode.api.v2.PaidLiquidityFeesConnection - 475, // 250: datanode.api.v2.PaidLiquidityFeesEdge.node:type_name -> vega.events.v1.PaidLiquidityFeesStats + 477, // 250: datanode.api.v2.PaidLiquidityFeesEdge.node:type_name -> vega.events.v1.PaidLiquidityFeesStats 232, // 251: datanode.api.v2.PaidLiquidityFeesConnection.edges:type_name -> datanode.api.v2.PaidLiquidityFeesEdge 7, // 252: datanode.api.v2.PaidLiquidityFeesConnection.page_info:type_name -> datanode.api.v2.PageInfo - 462, // 253: datanode.api.v2.GetGovernanceDataResponse.data:type_name -> vega.GovernanceData - 476, // 254: datanode.api.v2.ListGovernanceDataRequest.proposal_state:type_name -> vega.Proposal.State + 464, // 253: datanode.api.v2.GetGovernanceDataResponse.data:type_name -> vega.GovernanceData + 478, // 254: datanode.api.v2.ListGovernanceDataRequest.proposal_state:type_name -> vega.Proposal.State 5, // 255: datanode.api.v2.ListGovernanceDataRequest.proposal_type:type_name -> datanode.api.v2.ListGovernanceDataRequest.Type 6, // 256: datanode.api.v2.ListGovernanceDataRequest.pagination:type_name -> datanode.api.v2.Pagination 239, // 257: datanode.api.v2.ListGovernanceDataResponse.connection:type_name -> datanode.api.v2.GovernanceDataConnection - 462, // 258: datanode.api.v2.GovernanceDataEdge.node:type_name -> vega.GovernanceData + 464, // 258: datanode.api.v2.GovernanceDataEdge.node:type_name -> vega.GovernanceData 238, // 259: datanode.api.v2.GovernanceDataConnection.edges:type_name -> datanode.api.v2.GovernanceDataEdge 7, // 260: datanode.api.v2.GovernanceDataConnection.page_info:type_name -> datanode.api.v2.PageInfo - 462, // 261: datanode.api.v2.ObserveGovernanceResponse.data:type_name -> vega.GovernanceData + 464, // 261: datanode.api.v2.ObserveGovernanceResponse.data:type_name -> vega.GovernanceData 6, // 262: datanode.api.v2.ListDelegationsRequest.pagination:type_name -> datanode.api.v2.Pagination 245, // 263: datanode.api.v2.ListDelegationsResponse.delegations:type_name -> datanode.api.v2.DelegationsConnection - 477, // 264: datanode.api.v2.DelegationEdge.node:type_name -> vega.Delegation + 479, // 264: datanode.api.v2.DelegationEdge.node:type_name -> vega.Delegation 244, // 265: datanode.api.v2.DelegationsConnection.edges:type_name -> datanode.api.v2.DelegationEdge 7, // 266: datanode.api.v2.DelegationsConnection.page_info:type_name -> datanode.api.v2.PageInfo - 477, // 267: datanode.api.v2.ObserveDelegationsResponse.delegation:type_name -> vega.Delegation - 478, // 268: datanode.api.v2.NodeBasic.status:type_name -> vega.NodeStatus - 479, // 269: datanode.api.v2.GetNetworkDataResponse.node_data:type_name -> vega.NodeData - 480, // 270: datanode.api.v2.GetNodeResponse.node:type_name -> vega.Node + 479, // 267: datanode.api.v2.ObserveDelegationsResponse.delegation:type_name -> vega.Delegation + 480, // 268: datanode.api.v2.NodeBasic.status:type_name -> vega.NodeStatus + 481, // 269: datanode.api.v2.GetNetworkDataResponse.node_data:type_name -> vega.NodeData + 482, // 270: datanode.api.v2.GetNodeResponse.node:type_name -> vega.Node 6, // 271: datanode.api.v2.ListNodesRequest.pagination:type_name -> datanode.api.v2.Pagination 256, // 272: datanode.api.v2.ListNodesResponse.nodes:type_name -> datanode.api.v2.NodesConnection - 480, // 273: datanode.api.v2.NodeEdge.node:type_name -> vega.Node + 482, // 273: datanode.api.v2.NodeEdge.node:type_name -> vega.Node 255, // 274: datanode.api.v2.NodesConnection.edges:type_name -> datanode.api.v2.NodeEdge 7, // 275: datanode.api.v2.NodesConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 276: datanode.api.v2.ListNodeSignaturesRequest.pagination:type_name -> datanode.api.v2.Pagination 260, // 277: datanode.api.v2.ListNodeSignaturesResponse.signatures:type_name -> datanode.api.v2.NodeSignaturesConnection - 481, // 278: datanode.api.v2.NodeSignatureEdge.node:type_name -> vega.commands.v1.NodeSignature + 483, // 278: datanode.api.v2.NodeSignatureEdge.node:type_name -> vega.commands.v1.NodeSignature 259, // 279: datanode.api.v2.NodeSignaturesConnection.edges:type_name -> datanode.api.v2.NodeSignatureEdge 7, // 280: datanode.api.v2.NodeSignaturesConnection.page_info:type_name -> datanode.api.v2.PageInfo - 482, // 281: datanode.api.v2.GetEpochResponse.epoch:type_name -> vega.Epoch - 483, // 282: datanode.api.v2.EstimateFeeResponse.fee:type_name -> vega.Fee - 484, // 283: datanode.api.v2.EstimateMarginRequest.side:type_name -> vega.Side - 438, // 284: datanode.api.v2.EstimateMarginRequest.type:type_name -> vega.Order.Type - 465, // 285: datanode.api.v2.EstimateMarginResponse.margin_levels:type_name -> vega.MarginLevels + 484, // 281: datanode.api.v2.GetEpochResponse.epoch:type_name -> vega.Epoch + 485, // 282: datanode.api.v2.EstimateFeeResponse.fee:type_name -> vega.Fee + 486, // 283: datanode.api.v2.EstimateMarginRequest.side:type_name -> vega.Side + 440, // 284: datanode.api.v2.EstimateMarginRequest.type:type_name -> vega.Order.Type + 467, // 285: datanode.api.v2.EstimateMarginResponse.margin_levels:type_name -> vega.MarginLevels 6, // 286: datanode.api.v2.ListNetworkParametersRequest.pagination:type_name -> datanode.api.v2.Pagination 272, // 287: datanode.api.v2.ListNetworkParametersResponse.network_parameters:type_name -> datanode.api.v2.NetworkParameterConnection - 485, // 288: datanode.api.v2.GetNetworkParameterResponse.network_parameter:type_name -> vega.NetworkParameter - 485, // 289: datanode.api.v2.NetworkParameterEdge.node:type_name -> vega.NetworkParameter + 487, // 288: datanode.api.v2.GetNetworkParameterResponse.network_parameter:type_name -> vega.NetworkParameter + 487, // 289: datanode.api.v2.NetworkParameterEdge.node:type_name -> vega.NetworkParameter 271, // 290: datanode.api.v2.NetworkParameterConnection.edges:type_name -> datanode.api.v2.NetworkParameterEdge 7, // 291: datanode.api.v2.NetworkParameterConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 292: datanode.api.v2.ListCheckpointsRequest.pagination:type_name -> datanode.api.v2.Pagination @@ -32520,66 +32777,66 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 7, // 296: datanode.api.v2.CheckpointsConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 297: datanode.api.v2.GetStakeRequest.pagination:type_name -> datanode.api.v2.Pagination 281, // 298: datanode.api.v2.GetStakeResponse.stake_linkings:type_name -> datanode.api.v2.StakesConnection - 486, // 299: datanode.api.v2.StakeLinkingEdge.node:type_name -> vega.events.v1.StakeLinking + 488, // 299: datanode.api.v2.StakeLinkingEdge.node:type_name -> vega.events.v1.StakeLinking 280, // 300: datanode.api.v2.StakesConnection.edges:type_name -> datanode.api.v2.StakeLinkingEdge 7, // 301: datanode.api.v2.StakesConnection.page_info:type_name -> datanode.api.v2.PageInfo - 487, // 302: datanode.api.v2.GetRiskFactorsResponse.risk_factor:type_name -> vega.RiskFactor - 488, // 303: datanode.api.v2.ObserveEventBusRequest.type:type_name -> vega.events.v1.BusEventType - 489, // 304: datanode.api.v2.ObserveEventBusResponse.events:type_name -> vega.events.v1.BusEvent - 490, // 305: datanode.api.v2.ObserveLedgerMovementsResponse.ledger_movement:type_name -> vega.LedgerMovement + 489, // 302: datanode.api.v2.GetRiskFactorsResponse.risk_factor:type_name -> vega.RiskFactor + 490, // 303: datanode.api.v2.ObserveEventBusRequest.type:type_name -> vega.events.v1.BusEventType + 491, // 304: datanode.api.v2.ObserveEventBusResponse.events:type_name -> vega.events.v1.BusEvent + 492, // 305: datanode.api.v2.ObserveLedgerMovementsResponse.ledger_movement:type_name -> vega.LedgerMovement 6, // 306: datanode.api.v2.ListKeyRotationsRequest.pagination:type_name -> datanode.api.v2.Pagination 291, // 307: datanode.api.v2.ListKeyRotationsResponse.rotations:type_name -> datanode.api.v2.KeyRotationConnection - 491, // 308: datanode.api.v2.KeyRotationEdge.node:type_name -> vega.events.v1.KeyRotation + 493, // 308: datanode.api.v2.KeyRotationEdge.node:type_name -> vega.events.v1.KeyRotation 290, // 309: datanode.api.v2.KeyRotationConnection.edges:type_name -> datanode.api.v2.KeyRotationEdge 7, // 310: datanode.api.v2.KeyRotationConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 311: datanode.api.v2.ListEthereumKeyRotationsRequest.pagination:type_name -> datanode.api.v2.Pagination 294, // 312: datanode.api.v2.ListEthereumKeyRotationsResponse.key_rotations:type_name -> datanode.api.v2.EthereumKeyRotationsConnection 295, // 313: datanode.api.v2.EthereumKeyRotationsConnection.edges:type_name -> datanode.api.v2.EthereumKeyRotationEdge 7, // 314: datanode.api.v2.EthereumKeyRotationsConnection.page_info:type_name -> datanode.api.v2.PageInfo - 492, // 315: datanode.api.v2.EthereumKeyRotationEdge.node:type_name -> vega.events.v1.EthereumKeyRotation - 493, // 316: datanode.api.v2.ListProtocolUpgradeProposalsRequest.status:type_name -> vega.events.v1.ProtocolUpgradeProposalStatus + 494, // 315: datanode.api.v2.EthereumKeyRotationEdge.node:type_name -> vega.events.v1.EthereumKeyRotation + 495, // 316: datanode.api.v2.ListProtocolUpgradeProposalsRequest.status:type_name -> vega.events.v1.ProtocolUpgradeProposalStatus 6, // 317: datanode.api.v2.ListProtocolUpgradeProposalsRequest.pagination:type_name -> datanode.api.v2.Pagination 303, // 318: datanode.api.v2.ListProtocolUpgradeProposalsResponse.protocol_upgrade_proposals:type_name -> datanode.api.v2.ProtocolUpgradeProposalConnection 304, // 319: datanode.api.v2.ProtocolUpgradeProposalConnection.edges:type_name -> datanode.api.v2.ProtocolUpgradeProposalEdge 7, // 320: datanode.api.v2.ProtocolUpgradeProposalConnection.page_info:type_name -> datanode.api.v2.PageInfo - 494, // 321: datanode.api.v2.ProtocolUpgradeProposalEdge.node:type_name -> vega.events.v1.ProtocolUpgradeEvent + 496, // 321: datanode.api.v2.ProtocolUpgradeProposalEdge.node:type_name -> vega.events.v1.ProtocolUpgradeEvent 6, // 322: datanode.api.v2.ListCoreSnapshotsRequest.pagination:type_name -> datanode.api.v2.Pagination 307, // 323: datanode.api.v2.ListCoreSnapshotsResponse.core_snapshots:type_name -> datanode.api.v2.CoreSnapshotConnection 308, // 324: datanode.api.v2.CoreSnapshotConnection.edges:type_name -> datanode.api.v2.CoreSnapshotEdge 7, // 325: datanode.api.v2.CoreSnapshotConnection.page_info:type_name -> datanode.api.v2.PageInfo - 495, // 326: datanode.api.v2.CoreSnapshotEdge.node:type_name -> vega.events.v1.CoreSnapshotData + 497, // 326: datanode.api.v2.CoreSnapshotEdge.node:type_name -> vega.events.v1.CoreSnapshotData 309, // 327: datanode.api.v2.GetMostRecentNetworkHistorySegmentResponse.segment:type_name -> datanode.api.v2.HistorySegment 309, // 328: datanode.api.v2.ListAllNetworkHistorySegmentsResponse.segments:type_name -> datanode.api.v2.HistorySegment 3, // 329: datanode.api.v2.ExportNetworkHistoryRequest.table:type_name -> datanode.api.v2.Table - 496, // 330: datanode.api.v2.ListEntitiesResponse.accounts:type_name -> vega.Account - 436, // 331: datanode.api.v2.ListEntitiesResponse.orders:type_name -> vega.Order - 445, // 332: datanode.api.v2.ListEntitiesResponse.positions:type_name -> vega.Position - 497, // 333: datanode.api.v2.ListEntitiesResponse.ledger_entries:type_name -> vega.LedgerEntry + 498, // 330: datanode.api.v2.ListEntitiesResponse.accounts:type_name -> vega.Account + 438, // 331: datanode.api.v2.ListEntitiesResponse.orders:type_name -> vega.Order + 447, // 332: datanode.api.v2.ListEntitiesResponse.positions:type_name -> vega.Position + 499, // 333: datanode.api.v2.ListEntitiesResponse.ledger_entries:type_name -> vega.LedgerEntry 12, // 334: datanode.api.v2.ListEntitiesResponse.balance_changes:type_name -> datanode.api.v2.AccountBalance - 453, // 335: datanode.api.v2.ListEntitiesResponse.transfers:type_name -> vega.events.v1.Transfer - 456, // 336: datanode.api.v2.ListEntitiesResponse.votes:type_name -> vega.Vote + 455, // 335: datanode.api.v2.ListEntitiesResponse.transfers:type_name -> vega.events.v1.Transfer + 458, // 336: datanode.api.v2.ListEntitiesResponse.votes:type_name -> vega.Vote 123, // 337: datanode.api.v2.ListEntitiesResponse.erc20_multi_sig_signer_added_bundles:type_name -> datanode.api.v2.ERC20MultiSigSignerAddedBundle 129, // 338: datanode.api.v2.ListEntitiesResponse.erc20_multi_sig_signer_removed_bundles:type_name -> datanode.api.v2.ERC20MultiSigSignerRemovedBundle - 451, // 339: datanode.api.v2.ListEntitiesResponse.trades:type_name -> vega.Trade - 459, // 340: datanode.api.v2.ListEntitiesResponse.oracle_specs:type_name -> vega.OracleSpec - 460, // 341: datanode.api.v2.ListEntitiesResponse.oracle_data:type_name -> vega.OracleData - 461, // 342: datanode.api.v2.ListEntitiesResponse.markets:type_name -> vega.Market - 463, // 343: datanode.api.v2.ListEntitiesResponse.parties:type_name -> vega.Party - 465, // 344: datanode.api.v2.ListEntitiesResponse.margin_levels:type_name -> vega.MarginLevels - 466, // 345: datanode.api.v2.ListEntitiesResponse.rewards:type_name -> vega.Reward - 469, // 346: datanode.api.v2.ListEntitiesResponse.deposits:type_name -> vega.Deposit - 470, // 347: datanode.api.v2.ListEntitiesResponse.withdrawals:type_name -> vega.Withdrawal - 471, // 348: datanode.api.v2.ListEntitiesResponse.assets:type_name -> vega.Asset - 472, // 349: datanode.api.v2.ListEntitiesResponse.liquidity_provisions:type_name -> vega.LiquidityProvision - 498, // 350: datanode.api.v2.ListEntitiesResponse.proposals:type_name -> vega.Proposal - 477, // 351: datanode.api.v2.ListEntitiesResponse.delegations:type_name -> vega.Delegation + 453, // 339: datanode.api.v2.ListEntitiesResponse.trades:type_name -> vega.Trade + 461, // 340: datanode.api.v2.ListEntitiesResponse.oracle_specs:type_name -> vega.OracleSpec + 462, // 341: datanode.api.v2.ListEntitiesResponse.oracle_data:type_name -> vega.OracleData + 463, // 342: datanode.api.v2.ListEntitiesResponse.markets:type_name -> vega.Market + 465, // 343: datanode.api.v2.ListEntitiesResponse.parties:type_name -> vega.Party + 467, // 344: datanode.api.v2.ListEntitiesResponse.margin_levels:type_name -> vega.MarginLevels + 468, // 345: datanode.api.v2.ListEntitiesResponse.rewards:type_name -> vega.Reward + 471, // 346: datanode.api.v2.ListEntitiesResponse.deposits:type_name -> vega.Deposit + 472, // 347: datanode.api.v2.ListEntitiesResponse.withdrawals:type_name -> vega.Withdrawal + 473, // 348: datanode.api.v2.ListEntitiesResponse.assets:type_name -> vega.Asset + 474, // 349: datanode.api.v2.ListEntitiesResponse.liquidity_provisions:type_name -> vega.LiquidityProvision + 500, // 350: datanode.api.v2.ListEntitiesResponse.proposals:type_name -> vega.Proposal + 479, // 351: datanode.api.v2.ListEntitiesResponse.delegations:type_name -> vega.Delegation 248, // 352: datanode.api.v2.ListEntitiesResponse.nodes:type_name -> datanode.api.v2.NodeBasic - 481, // 353: datanode.api.v2.ListEntitiesResponse.node_signatures:type_name -> vega.commands.v1.NodeSignature - 485, // 354: datanode.api.v2.ListEntitiesResponse.network_parameters:type_name -> vega.NetworkParameter - 491, // 355: datanode.api.v2.ListEntitiesResponse.key_rotations:type_name -> vega.events.v1.KeyRotation - 492, // 356: datanode.api.v2.ListEntitiesResponse.ethereum_key_rotations:type_name -> vega.events.v1.EthereumKeyRotation - 494, // 357: datanode.api.v2.ListEntitiesResponse.protocol_upgrade_proposals:type_name -> vega.events.v1.ProtocolUpgradeEvent - 499, // 358: datanode.api.v2.GetPartyActivityStreakResponse.activity_streak:type_name -> vega.events.v1.PartyActivityStreak + 483, // 353: datanode.api.v2.ListEntitiesResponse.node_signatures:type_name -> vega.commands.v1.NodeSignature + 487, // 354: datanode.api.v2.ListEntitiesResponse.network_parameters:type_name -> vega.NetworkParameter + 493, // 355: datanode.api.v2.ListEntitiesResponse.key_rotations:type_name -> vega.events.v1.KeyRotation + 494, // 356: datanode.api.v2.ListEntitiesResponse.ethereum_key_rotations:type_name -> vega.events.v1.EthereumKeyRotation + 496, // 357: datanode.api.v2.ListEntitiesResponse.protocol_upgrade_proposals:type_name -> vega.events.v1.ProtocolUpgradeEvent + 501, // 358: datanode.api.v2.GetPartyActivityStreakResponse.activity_streak:type_name -> vega.events.v1.PartyActivityStreak 6, // 359: datanode.api.v2.ListFundingPaymentsRequest.pagination:type_name -> datanode.api.v2.Pagination 325, // 360: datanode.api.v2.FundingPaymentEdge.node:type_name -> datanode.api.v2.FundingPayment 327, // 361: datanode.api.v2.FundingPaymentConnection.edges:type_name -> datanode.api.v2.FundingPaymentEdge @@ -32587,30 +32844,30 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 328, // 363: datanode.api.v2.ListFundingPaymentsResponse.funding_payments:type_name -> datanode.api.v2.FundingPaymentConnection 298, // 364: datanode.api.v2.ListFundingPeriodsRequest.date_range:type_name -> datanode.api.v2.DateRange 6, // 365: datanode.api.v2.ListFundingPeriodsRequest.pagination:type_name -> datanode.api.v2.Pagination - 500, // 366: datanode.api.v2.FundingPeriodEdge.node:type_name -> vega.events.v1.FundingPeriod + 502, // 366: datanode.api.v2.FundingPeriodEdge.node:type_name -> vega.events.v1.FundingPeriod 331, // 367: datanode.api.v2.FundingPeriodConnection.edges:type_name -> datanode.api.v2.FundingPeriodEdge 7, // 368: datanode.api.v2.FundingPeriodConnection.page_info:type_name -> datanode.api.v2.PageInfo 332, // 369: datanode.api.v2.ListFundingPeriodsResponse.funding_periods:type_name -> datanode.api.v2.FundingPeriodConnection 298, // 370: datanode.api.v2.ListFundingPeriodDataPointsRequest.date_range:type_name -> datanode.api.v2.DateRange - 501, // 371: datanode.api.v2.ListFundingPeriodDataPointsRequest.source:type_name -> vega.events.v1.FundingPeriodDataPoint.Source + 503, // 371: datanode.api.v2.ListFundingPeriodDataPointsRequest.source:type_name -> vega.events.v1.FundingPeriodDataPoint.Source 6, // 372: datanode.api.v2.ListFundingPeriodDataPointsRequest.pagination:type_name -> datanode.api.v2.Pagination - 502, // 373: datanode.api.v2.FundingPeriodDataPointEdge.node:type_name -> vega.events.v1.FundingPeriodDataPoint + 504, // 373: datanode.api.v2.FundingPeriodDataPointEdge.node:type_name -> vega.events.v1.FundingPeriodDataPoint 335, // 374: datanode.api.v2.FundingPeriodDataPointConnection.edges:type_name -> datanode.api.v2.FundingPeriodDataPointEdge 7, // 375: datanode.api.v2.FundingPeriodDataPointConnection.page_info:type_name -> datanode.api.v2.PageInfo 336, // 376: datanode.api.v2.ListFundingPeriodDataPointsResponse.funding_period_data_points:type_name -> datanode.api.v2.FundingPeriodDataPointConnection - 484, // 377: datanode.api.v2.OrderInfo.side:type_name -> vega.Side + 486, // 377: datanode.api.v2.OrderInfo.side:type_name -> vega.Side 340, // 378: datanode.api.v2.EstimatePositionRequest.orders:type_name -> datanode.api.v2.OrderInfo - 503, // 379: datanode.api.v2.EstimatePositionRequest.margin_mode:type_name -> vega.MarginMode + 505, // 379: datanode.api.v2.EstimatePositionRequest.margin_mode:type_name -> vega.MarginMode 344, // 380: datanode.api.v2.EstimatePositionResponse.margin:type_name -> datanode.api.v2.MarginEstimate 343, // 381: datanode.api.v2.EstimatePositionResponse.collateral_increase_estimate:type_name -> datanode.api.v2.CollateralIncreaseEstimate 345, // 382: datanode.api.v2.EstimatePositionResponse.liquidation:type_name -> datanode.api.v2.LiquidationEstimate - 465, // 383: datanode.api.v2.MarginEstimate.worst_case:type_name -> vega.MarginLevels - 465, // 384: datanode.api.v2.MarginEstimate.best_case:type_name -> vega.MarginLevels + 467, // 383: datanode.api.v2.MarginEstimate.worst_case:type_name -> vega.MarginLevels + 467, // 384: datanode.api.v2.MarginEstimate.best_case:type_name -> vega.MarginLevels 346, // 385: datanode.api.v2.LiquidationEstimate.worst_case:type_name -> datanode.api.v2.LiquidationPrice 346, // 386: datanode.api.v2.LiquidationEstimate.best_case:type_name -> datanode.api.v2.LiquidationPrice 349, // 387: datanode.api.v2.GetCurrentReferralProgramResponse.current_referral_program:type_name -> datanode.api.v2.ReferralProgram - 504, // 388: datanode.api.v2.ReferralProgram.benefit_tiers:type_name -> vega.BenefitTier - 505, // 389: datanode.api.v2.ReferralProgram.staking_tiers:type_name -> vega.StakingTier + 506, // 388: datanode.api.v2.ReferralProgram.benefit_tiers:type_name -> vega.BenefitTier + 507, // 389: datanode.api.v2.ReferralProgram.staking_tiers:type_name -> vega.StakingTier 350, // 390: datanode.api.v2.ReferralSetEdge.node:type_name -> datanode.api.v2.ReferralSet 351, // 391: datanode.api.v2.ReferralSetConnection.edges:type_name -> datanode.api.v2.ReferralSetEdge 7, // 392: datanode.api.v2.ReferralSetConnection.page_info:type_name -> datanode.api.v2.PageInfo @@ -32655,7 +32912,7 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 7, // 431: datanode.api.v2.TeamRefereeHistoryConnection.page_info:type_name -> datanode.api.v2.PageInfo 6, // 432: datanode.api.v2.ListTeamRefereeHistoryRequest.pagination:type_name -> datanode.api.v2.Pagination 389, // 433: datanode.api.v2.ListTeamRefereeHistoryResponse.team_referee_history:type_name -> datanode.api.v2.TeamRefereeHistoryConnection - 506, // 434: datanode.api.v2.GetFeesStatsResponse.fees_stats:type_name -> vega.events.v1.FeesStats + 508, // 434: datanode.api.v2.GetFeesStatsResponse.fees_stats:type_name -> vega.events.v1.FeesStats 404, // 435: datanode.api.v2.GetFeesStatsForPartyResponse.fees_stats_for_party:type_name -> datanode.api.v2.FeesStatsForParty 403, // 436: datanode.api.v2.GetCurrentVolumeDiscountProgramResponse.current_volume_discount_program:type_name -> datanode.api.v2.VolumeDiscountProgram 6, // 437: datanode.api.v2.GetVolumeDiscountStatsRequest.pagination:type_name -> datanode.api.v2.Pagination @@ -32663,10 +32920,10 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 401, // 439: datanode.api.v2.VolumeDiscountStatsConnection.edges:type_name -> datanode.api.v2.VolumeDiscountStatsEdge 7, // 440: datanode.api.v2.VolumeDiscountStatsConnection.page_info:type_name -> datanode.api.v2.PageInfo 402, // 441: datanode.api.v2.VolumeDiscountStatsEdge.node:type_name -> datanode.api.v2.VolumeDiscountStats - 507, // 442: datanode.api.v2.VolumeDiscountProgram.benefit_tiers:type_name -> vega.VolumeBenefitTier - 508, // 443: datanode.api.v2.ObserveTransactionResultsResponse.transaction_results:type_name -> vega.events.v1.TransactionResult - 435, // 444: datanode.api.v2.EstimateTransferFeeRequest.from_account_type:type_name -> vega.AccountType - 509, // 445: datanode.api.v2.ListGamesRequest.entity_scope:type_name -> vega.EntityScope + 509, // 442: datanode.api.v2.VolumeDiscountProgram.benefit_tiers:type_name -> vega.VolumeBenefitTier + 510, // 443: datanode.api.v2.ObserveTransactionResultsResponse.transaction_results:type_name -> vega.events.v1.TransactionResult + 437, // 444: datanode.api.v2.EstimateTransferFeeRequest.from_account_type:type_name -> vega.AccountType + 511, // 445: datanode.api.v2.ListGamesRequest.entity_scope:type_name -> vega.EntityScope 6, // 446: datanode.api.v2.ListGamesRequest.pagination:type_name -> datanode.api.v2.Pagination 413, // 447: datanode.api.v2.ListGamesResponse.games:type_name -> datanode.api.v2.GamesConnection 414, // 448: datanode.api.v2.GamesConnection.edges:type_name -> datanode.api.v2.GameEdge @@ -32677,22 +32934,22 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 418, // 453: datanode.api.v2.TeamGameEntities.team:type_name -> datanode.api.v2.TeamGameEntity 420, // 454: datanode.api.v2.IndividualGameEntities.individual:type_name -> datanode.api.v2.IndividualGameEntity 419, // 455: datanode.api.v2.TeamGameEntity.team:type_name -> datanode.api.v2.TeamGameParticipation - 510, // 456: datanode.api.v2.TeamGameEntity.reward_metric:type_name -> vega.DispatchMetric + 512, // 456: datanode.api.v2.TeamGameEntity.reward_metric:type_name -> vega.DispatchMetric 420, // 457: datanode.api.v2.TeamGameParticipation.members_participating:type_name -> datanode.api.v2.IndividualGameEntity - 510, // 458: datanode.api.v2.IndividualGameEntity.reward_metric:type_name -> vega.DispatchMetric + 512, // 458: datanode.api.v2.IndividualGameEntity.reward_metric:type_name -> vega.DispatchMetric 6, // 459: datanode.api.v2.ListPartyMarginModesRequest.pagination:type_name -> datanode.api.v2.Pagination 423, // 460: datanode.api.v2.ListPartyMarginModesResponse.party_margin_modes:type_name -> datanode.api.v2.PartyMarginModesConnection 424, // 461: datanode.api.v2.PartyMarginModesConnection.edges:type_name -> datanode.api.v2.PartyMarginModeEdge 7, // 462: datanode.api.v2.PartyMarginModesConnection.page_info:type_name -> datanode.api.v2.PageInfo 425, // 463: datanode.api.v2.PartyMarginModeEdge.node:type_name -> datanode.api.v2.PartyMarginMode - 503, // 464: datanode.api.v2.PartyMarginMode.margin_mode:type_name -> vega.MarginMode + 505, // 464: datanode.api.v2.PartyMarginMode.margin_mode:type_name -> vega.MarginMode 426, // 465: datanode.api.v2.GetTimeWeightedNotionalPositionResponse.time_weighted_notional_position:type_name -> datanode.api.v2.TimeWeightedNotionalPosition - 511, // 466: datanode.api.v2.ListAMMsRequest.status:type_name -> vega.events.v1.AMM.Status + 513, // 466: datanode.api.v2.ListAMMsRequest.status:type_name -> vega.events.v1.AMM.Status 6, // 467: datanode.api.v2.ListAMMsRequest.pagination:type_name -> datanode.api.v2.Pagination 431, // 468: datanode.api.v2.ListAMMsResponse.amms:type_name -> datanode.api.v2.AMMConnection 432, // 469: datanode.api.v2.AMMConnection.edges:type_name -> datanode.api.v2.AMMEdge 7, // 470: datanode.api.v2.AMMConnection.page_info:type_name -> datanode.api.v2.PageInfo - 512, // 471: datanode.api.v2.AMMEdge.node:type_name -> vega.events.v1.AMM + 514, // 471: datanode.api.v2.AMMEdge.node:type_name -> vega.events.v1.AMM 13, // 472: datanode.api.v2.TradingDataService.ListAccounts:input_type -> datanode.api.v2.ListAccountsRequest 17, // 473: datanode.api.v2.TradingDataService.ObserveAccounts:input_type -> datanode.api.v2.ObserveAccountsRequest 21, // 474: datanode.api.v2.TradingDataService.Info:input_type -> datanode.api.v2.InfoRequest @@ -32815,134 +33072,136 @@ var file_data_node_api_v2_trading_data_proto_depIdxs = []int32{ 421, // 591: datanode.api.v2.TradingDataService.ListPartyMarginModes:input_type -> datanode.api.v2.ListPartyMarginModesRequest 427, // 592: datanode.api.v2.TradingDataService.GetTimeWeightedNotionalPosition:input_type -> datanode.api.v2.GetTimeWeightedNotionalPositionRequest 429, // 593: datanode.api.v2.TradingDataService.ListAMMs:input_type -> datanode.api.v2.ListAMMsRequest - 320, // 594: datanode.api.v2.TradingDataService.ExportNetworkHistory:input_type -> datanode.api.v2.ExportNetworkHistoryRequest - 338, // 595: datanode.api.v2.TradingDataService.Ping:input_type -> datanode.api.v2.PingRequest - 14, // 596: datanode.api.v2.TradingDataService.ListAccounts:output_type -> datanode.api.v2.ListAccountsResponse - 18, // 597: datanode.api.v2.TradingDataService.ObserveAccounts:output_type -> datanode.api.v2.ObserveAccountsResponse - 22, // 598: datanode.api.v2.TradingDataService.Info:output_type -> datanode.api.v2.InfoResponse - 24, // 599: datanode.api.v2.TradingDataService.GetOrder:output_type -> datanode.api.v2.GetOrderResponse - 27, // 600: datanode.api.v2.TradingDataService.ListOrders:output_type -> datanode.api.v2.ListOrdersResponse - 29, // 601: datanode.api.v2.TradingDataService.ListOrderVersions:output_type -> datanode.api.v2.ListOrderVersionsResponse - 31, // 602: datanode.api.v2.TradingDataService.ObserveOrders:output_type -> datanode.api.v2.ObserveOrdersResponse - 35, // 603: datanode.api.v2.TradingDataService.GetStopOrder:output_type -> datanode.api.v2.GetStopOrderResponse - 50, // 604: datanode.api.v2.TradingDataService.ListStopOrders:output_type -> datanode.api.v2.ListStopOrdersResponse - 38, // 605: datanode.api.v2.TradingDataService.ListGameTeamScores:output_type -> datanode.api.v2.ListGameTeamScoresResponse - 43, // 606: datanode.api.v2.TradingDataService.ListGamePartyScores:output_type -> datanode.api.v2.ListGamePartyScoresResponse - 52, // 607: datanode.api.v2.TradingDataService.ListPositions:output_type -> datanode.api.v2.ListPositionsResponse - 55, // 608: datanode.api.v2.TradingDataService.ListAllPositions:output_type -> datanode.api.v2.ListAllPositionsResponse - 59, // 609: datanode.api.v2.TradingDataService.ObservePositions:output_type -> datanode.api.v2.ObservePositionsResponse - 66, // 610: datanode.api.v2.TradingDataService.ListLedgerEntries:output_type -> datanode.api.v2.ListLedgerEntriesResponse - 513, // 611: datanode.api.v2.TradingDataService.ExportLedgerEntries:output_type -> google.api.HttpBody - 70, // 612: datanode.api.v2.TradingDataService.ListBalanceChanges:output_type -> datanode.api.v2.ListBalanceChangesResponse - 88, // 613: datanode.api.v2.TradingDataService.GetLatestMarketData:output_type -> datanode.api.v2.GetLatestMarketDataResponse - 86, // 614: datanode.api.v2.TradingDataService.ListLatestMarketData:output_type -> datanode.api.v2.ListLatestMarketDataResponse - 84, // 615: datanode.api.v2.TradingDataService.GetLatestMarketDepth:output_type -> datanode.api.v2.GetLatestMarketDepthResponse - 78, // 616: datanode.api.v2.TradingDataService.ObserveMarketsDepth:output_type -> datanode.api.v2.ObserveMarketsDepthResponse - 80, // 617: datanode.api.v2.TradingDataService.ObserveMarketsDepthUpdates:output_type -> datanode.api.v2.ObserveMarketsDepthUpdatesResponse - 82, // 618: datanode.api.v2.TradingDataService.ObserveMarketsData:output_type -> datanode.api.v2.ObserveMarketsDataResponse - 90, // 619: datanode.api.v2.TradingDataService.GetMarketDataHistoryByID:output_type -> datanode.api.v2.GetMarketDataHistoryByIDResponse - 94, // 620: datanode.api.v2.TradingDataService.ListTransfers:output_type -> datanode.api.v2.ListTransfersResponse - 99, // 621: datanode.api.v2.TradingDataService.GetTransfer:output_type -> datanode.api.v2.GetTransferResponse - 101, // 622: datanode.api.v2.TradingDataService.GetNetworkLimits:output_type -> datanode.api.v2.GetNetworkLimitsResponse - 109, // 623: datanode.api.v2.TradingDataService.ListCandleData:output_type -> datanode.api.v2.ListCandleDataResponse - 107, // 624: datanode.api.v2.TradingDataService.ObserveCandleData:output_type -> datanode.api.v2.ObserveCandleDataResponse - 104, // 625: datanode.api.v2.TradingDataService.ListCandleIntervals:output_type -> datanode.api.v2.ListCandleIntervalsResponse - 113, // 626: datanode.api.v2.TradingDataService.ListVotes:output_type -> datanode.api.v2.ListVotesResponse - 117, // 627: datanode.api.v2.TradingDataService.ObserveVotes:output_type -> datanode.api.v2.ObserveVotesResponse - 119, // 628: datanode.api.v2.TradingDataService.ListERC20MultiSigSignerAddedBundles:output_type -> datanode.api.v2.ListERC20MultiSigSignerAddedBundlesResponse - 125, // 629: datanode.api.v2.TradingDataService.ListERC20MultiSigSignerRemovedBundles:output_type -> datanode.api.v2.ListERC20MultiSigSignerRemovedBundlesResponse - 131, // 630: datanode.api.v2.TradingDataService.GetERC20ListAssetBundle:output_type -> datanode.api.v2.GetERC20ListAssetBundleResponse - 133, // 631: datanode.api.v2.TradingDataService.GetERC20SetAssetLimitsBundle:output_type -> datanode.api.v2.GetERC20SetAssetLimitsBundleResponse - 135, // 632: datanode.api.v2.TradingDataService.GetERC20WithdrawalApproval:output_type -> datanode.api.v2.GetERC20WithdrawalApprovalResponse - 137, // 633: datanode.api.v2.TradingDataService.GetLastTrade:output_type -> datanode.api.v2.GetLastTradeResponse - 139, // 634: datanode.api.v2.TradingDataService.ListTrades:output_type -> datanode.api.v2.ListTradesResponse - 143, // 635: datanode.api.v2.TradingDataService.ObserveTrades:output_type -> datanode.api.v2.ObserveTradesResponse - 145, // 636: datanode.api.v2.TradingDataService.GetOracleSpec:output_type -> datanode.api.v2.GetOracleSpecResponse - 147, // 637: datanode.api.v2.TradingDataService.ListOracleSpecs:output_type -> datanode.api.v2.ListOracleSpecsResponse - 149, // 638: datanode.api.v2.TradingDataService.ListOracleData:output_type -> datanode.api.v2.ListOracleDataResponse - 155, // 639: datanode.api.v2.TradingDataService.GetMarket:output_type -> datanode.api.v2.GetMarketResponse - 157, // 640: datanode.api.v2.TradingDataService.ListMarkets:output_type -> datanode.api.v2.ListMarketsResponse - 164, // 641: datanode.api.v2.TradingDataService.ListSuccessorMarkets:output_type -> datanode.api.v2.ListSuccessorMarketsResponse - 166, // 642: datanode.api.v2.TradingDataService.GetParty:output_type -> datanode.api.v2.GetPartyResponse - 168, // 643: datanode.api.v2.TradingDataService.ListParties:output_type -> datanode.api.v2.ListPartiesResponse - 172, // 644: datanode.api.v2.TradingDataService.ListPartiesProfiles:output_type -> datanode.api.v2.ListPartiesProfilesResponse - 177, // 645: datanode.api.v2.TradingDataService.ListMarginLevels:output_type -> datanode.api.v2.ListMarginLevelsResponse - 179, // 646: datanode.api.v2.TradingDataService.ObserveMarginLevels:output_type -> datanode.api.v2.ObserveMarginLevelsResponse - 184, // 647: datanode.api.v2.TradingDataService.ListRewards:output_type -> datanode.api.v2.ListRewardsResponse - 188, // 648: datanode.api.v2.TradingDataService.ListRewardSummaries:output_type -> datanode.api.v2.ListRewardSummariesResponse - 191, // 649: datanode.api.v2.TradingDataService.ListEpochRewardSummaries:output_type -> datanode.api.v2.ListEpochRewardSummariesResponse - 197, // 650: datanode.api.v2.TradingDataService.GetDeposit:output_type -> datanode.api.v2.GetDepositResponse - 199, // 651: datanode.api.v2.TradingDataService.ListDeposits:output_type -> datanode.api.v2.ListDepositsResponse - 203, // 652: datanode.api.v2.TradingDataService.GetWithdrawal:output_type -> datanode.api.v2.GetWithdrawalResponse - 205, // 653: datanode.api.v2.TradingDataService.ListWithdrawals:output_type -> datanode.api.v2.ListWithdrawalsResponse - 209, // 654: datanode.api.v2.TradingDataService.GetAsset:output_type -> datanode.api.v2.GetAssetResponse - 211, // 655: datanode.api.v2.TradingDataService.ListAssets:output_type -> datanode.api.v2.ListAssetsResponse - 216, // 656: datanode.api.v2.TradingDataService.ListLiquidityProvisions:output_type -> datanode.api.v2.ListLiquidityProvisionsResponse - 217, // 657: datanode.api.v2.TradingDataService.ListAllLiquidityProvisions:output_type -> datanode.api.v2.ListAllLiquidityProvisionsResponse - 224, // 658: datanode.api.v2.TradingDataService.ObserveLiquidityProvisions:output_type -> datanode.api.v2.ObserveLiquidityProvisionsResponse - 229, // 659: datanode.api.v2.TradingDataService.ListLiquidityProviders:output_type -> datanode.api.v2.ListLiquidityProvidersResponse - 231, // 660: datanode.api.v2.TradingDataService.ListPaidLiquidityFees:output_type -> datanode.api.v2.ListPaidLiquidityFeesResponse - 235, // 661: datanode.api.v2.TradingDataService.GetGovernanceData:output_type -> datanode.api.v2.GetGovernanceDataResponse - 237, // 662: datanode.api.v2.TradingDataService.ListGovernanceData:output_type -> datanode.api.v2.ListGovernanceDataResponse - 241, // 663: datanode.api.v2.TradingDataService.ObserveGovernance:output_type -> datanode.api.v2.ObserveGovernanceResponse - 243, // 664: datanode.api.v2.TradingDataService.ListDelegations:output_type -> datanode.api.v2.ListDelegationsResponse - 250, // 665: datanode.api.v2.TradingDataService.GetNetworkData:output_type -> datanode.api.v2.GetNetworkDataResponse - 252, // 666: datanode.api.v2.TradingDataService.GetNode:output_type -> datanode.api.v2.GetNodeResponse - 254, // 667: datanode.api.v2.TradingDataService.ListNodes:output_type -> datanode.api.v2.ListNodesResponse - 258, // 668: datanode.api.v2.TradingDataService.ListNodeSignatures:output_type -> datanode.api.v2.ListNodeSignaturesResponse - 262, // 669: datanode.api.v2.TradingDataService.GetEpoch:output_type -> datanode.api.v2.GetEpochResponse - 264, // 670: datanode.api.v2.TradingDataService.EstimateFee:output_type -> datanode.api.v2.EstimateFeeResponse - 266, // 671: datanode.api.v2.TradingDataService.EstimateMargin:output_type -> datanode.api.v2.EstimateMarginResponse - 342, // 672: datanode.api.v2.TradingDataService.EstimatePosition:output_type -> datanode.api.v2.EstimatePositionResponse - 268, // 673: datanode.api.v2.TradingDataService.ListNetworkParameters:output_type -> datanode.api.v2.ListNetworkParametersResponse - 270, // 674: datanode.api.v2.TradingDataService.GetNetworkParameter:output_type -> datanode.api.v2.GetNetworkParameterResponse - 275, // 675: datanode.api.v2.TradingDataService.ListCheckpoints:output_type -> datanode.api.v2.ListCheckpointsResponse - 279, // 676: datanode.api.v2.TradingDataService.GetStake:output_type -> datanode.api.v2.GetStakeResponse - 283, // 677: datanode.api.v2.TradingDataService.GetRiskFactors:output_type -> datanode.api.v2.GetRiskFactorsResponse - 285, // 678: datanode.api.v2.TradingDataService.ObserveEventBus:output_type -> datanode.api.v2.ObserveEventBusResponse - 287, // 679: datanode.api.v2.TradingDataService.ObserveLedgerMovements:output_type -> datanode.api.v2.ObserveLedgerMovementsResponse - 289, // 680: datanode.api.v2.TradingDataService.ListKeyRotations:output_type -> datanode.api.v2.ListKeyRotationsResponse - 293, // 681: datanode.api.v2.TradingDataService.ListEthereumKeyRotations:output_type -> datanode.api.v2.ListEthereumKeyRotationsResponse - 297, // 682: datanode.api.v2.TradingDataService.GetVegaTime:output_type -> datanode.api.v2.GetVegaTimeResponse - 300, // 683: datanode.api.v2.TradingDataService.GetProtocolUpgradeStatus:output_type -> datanode.api.v2.GetProtocolUpgradeStatusResponse - 302, // 684: datanode.api.v2.TradingDataService.ListProtocolUpgradeProposals:output_type -> datanode.api.v2.ListProtocolUpgradeProposalsResponse - 306, // 685: datanode.api.v2.TradingDataService.ListCoreSnapshots:output_type -> datanode.api.v2.ListCoreSnapshotsResponse - 311, // 686: datanode.api.v2.TradingDataService.GetMostRecentNetworkHistorySegment:output_type -> datanode.api.v2.GetMostRecentNetworkHistorySegmentResponse - 313, // 687: datanode.api.v2.TradingDataService.ListAllNetworkHistorySegments:output_type -> datanode.api.v2.ListAllNetworkHistorySegmentsResponse - 315, // 688: datanode.api.v2.TradingDataService.GetActiveNetworkHistoryPeerAddresses:output_type -> datanode.api.v2.GetActiveNetworkHistoryPeerAddressesResponse - 317, // 689: datanode.api.v2.TradingDataService.GetNetworkHistoryStatus:output_type -> datanode.api.v2.GetNetworkHistoryStatusResponse - 319, // 690: datanode.api.v2.TradingDataService.GetNetworkHistoryBootstrapPeers:output_type -> datanode.api.v2.GetNetworkHistoryBootstrapPeersResponse - 322, // 691: datanode.api.v2.TradingDataService.ListEntities:output_type -> datanode.api.v2.ListEntitiesResponse - 333, // 692: datanode.api.v2.TradingDataService.ListFundingPeriods:output_type -> datanode.api.v2.ListFundingPeriodsResponse - 337, // 693: datanode.api.v2.TradingDataService.ListFundingPeriodDataPoints:output_type -> datanode.api.v2.ListFundingPeriodDataPointsResponse - 329, // 694: datanode.api.v2.TradingDataService.ListFundingPayments:output_type -> datanode.api.v2.ListFundingPaymentsResponse - 324, // 695: datanode.api.v2.TradingDataService.GetPartyActivityStreak:output_type -> datanode.api.v2.GetPartyActivityStreakResponse - 348, // 696: datanode.api.v2.TradingDataService.GetCurrentReferralProgram:output_type -> datanode.api.v2.GetCurrentReferralProgramResponse - 354, // 697: datanode.api.v2.TradingDataService.ListReferralSets:output_type -> datanode.api.v2.ListReferralSetsResponse - 359, // 698: datanode.api.v2.TradingDataService.ListReferralSetReferees:output_type -> datanode.api.v2.ListReferralSetRefereesResponse - 361, // 699: datanode.api.v2.TradingDataService.GetReferralSetStats:output_type -> datanode.api.v2.GetReferralSetStatsResponse - 369, // 700: datanode.api.v2.TradingDataService.ListTeams:output_type -> datanode.api.v2.ListTeamsResponse - 371, // 701: datanode.api.v2.TradingDataService.ListTeamsStatistics:output_type -> datanode.api.v2.ListTeamsStatisticsResponse - 378, // 702: datanode.api.v2.TradingDataService.ListTeamMembersStatistics:output_type -> datanode.api.v2.ListTeamMembersStatisticsResponse - 386, // 703: datanode.api.v2.TradingDataService.ListTeamReferees:output_type -> datanode.api.v2.ListTeamRefereesResponse - 391, // 704: datanode.api.v2.TradingDataService.ListTeamRefereeHistory:output_type -> datanode.api.v2.ListTeamRefereeHistoryResponse - 393, // 705: datanode.api.v2.TradingDataService.GetFeesStats:output_type -> datanode.api.v2.GetFeesStatsResponse - 395, // 706: datanode.api.v2.TradingDataService.GetFeesStatsForParty:output_type -> datanode.api.v2.GetFeesStatsForPartyResponse - 397, // 707: datanode.api.v2.TradingDataService.GetCurrentVolumeDiscountProgram:output_type -> datanode.api.v2.GetCurrentVolumeDiscountProgramResponse - 399, // 708: datanode.api.v2.TradingDataService.GetVolumeDiscountStats:output_type -> datanode.api.v2.GetVolumeDiscountStatsResponse - 11, // 709: datanode.api.v2.TradingDataService.GetVestingBalancesSummary:output_type -> datanode.api.v2.GetVestingBalancesSummaryResponse - 9, // 710: datanode.api.v2.TradingDataService.GetPartyVestingStats:output_type -> datanode.api.v2.GetPartyVestingStatsResponse - 406, // 711: datanode.api.v2.TradingDataService.ObserveTransactionResults:output_type -> datanode.api.v2.ObserveTransactionResultsResponse - 408, // 712: datanode.api.v2.TradingDataService.EstimateTransferFee:output_type -> datanode.api.v2.EstimateTransferFeeResponse - 410, // 713: datanode.api.v2.TradingDataService.GetTotalTransferFeeDiscount:output_type -> datanode.api.v2.GetTotalTransferFeeDiscountResponse - 412, // 714: datanode.api.v2.TradingDataService.ListGames:output_type -> datanode.api.v2.ListGamesResponse - 422, // 715: datanode.api.v2.TradingDataService.ListPartyMarginModes:output_type -> datanode.api.v2.ListPartyMarginModesResponse - 428, // 716: datanode.api.v2.TradingDataService.GetTimeWeightedNotionalPosition:output_type -> datanode.api.v2.GetTimeWeightedNotionalPositionResponse - 430, // 717: datanode.api.v2.TradingDataService.ListAMMs:output_type -> datanode.api.v2.ListAMMsResponse - 513, // 718: datanode.api.v2.TradingDataService.ExportNetworkHistory:output_type -> google.api.HttpBody - 339, // 719: datanode.api.v2.TradingDataService.Ping:output_type -> datanode.api.v2.PingResponse - 596, // [596:720] is the sub-list for method output_type - 472, // [472:596] is the sub-list for method input_type + 433, // 594: datanode.api.v2.TradingDataService.EstimateAMMBounds:input_type -> datanode.api.v2.EstimateAMMBoundsRequest + 320, // 595: datanode.api.v2.TradingDataService.ExportNetworkHistory:input_type -> datanode.api.v2.ExportNetworkHistoryRequest + 338, // 596: datanode.api.v2.TradingDataService.Ping:input_type -> datanode.api.v2.PingRequest + 14, // 597: datanode.api.v2.TradingDataService.ListAccounts:output_type -> datanode.api.v2.ListAccountsResponse + 18, // 598: datanode.api.v2.TradingDataService.ObserveAccounts:output_type -> datanode.api.v2.ObserveAccountsResponse + 22, // 599: datanode.api.v2.TradingDataService.Info:output_type -> datanode.api.v2.InfoResponse + 24, // 600: datanode.api.v2.TradingDataService.GetOrder:output_type -> datanode.api.v2.GetOrderResponse + 27, // 601: datanode.api.v2.TradingDataService.ListOrders:output_type -> datanode.api.v2.ListOrdersResponse + 29, // 602: datanode.api.v2.TradingDataService.ListOrderVersions:output_type -> datanode.api.v2.ListOrderVersionsResponse + 31, // 603: datanode.api.v2.TradingDataService.ObserveOrders:output_type -> datanode.api.v2.ObserveOrdersResponse + 35, // 604: datanode.api.v2.TradingDataService.GetStopOrder:output_type -> datanode.api.v2.GetStopOrderResponse + 50, // 605: datanode.api.v2.TradingDataService.ListStopOrders:output_type -> datanode.api.v2.ListStopOrdersResponse + 38, // 606: datanode.api.v2.TradingDataService.ListGameTeamScores:output_type -> datanode.api.v2.ListGameTeamScoresResponse + 43, // 607: datanode.api.v2.TradingDataService.ListGamePartyScores:output_type -> datanode.api.v2.ListGamePartyScoresResponse + 52, // 608: datanode.api.v2.TradingDataService.ListPositions:output_type -> datanode.api.v2.ListPositionsResponse + 55, // 609: datanode.api.v2.TradingDataService.ListAllPositions:output_type -> datanode.api.v2.ListAllPositionsResponse + 59, // 610: datanode.api.v2.TradingDataService.ObservePositions:output_type -> datanode.api.v2.ObservePositionsResponse + 66, // 611: datanode.api.v2.TradingDataService.ListLedgerEntries:output_type -> datanode.api.v2.ListLedgerEntriesResponse + 515, // 612: datanode.api.v2.TradingDataService.ExportLedgerEntries:output_type -> google.api.HttpBody + 70, // 613: datanode.api.v2.TradingDataService.ListBalanceChanges:output_type -> datanode.api.v2.ListBalanceChangesResponse + 88, // 614: datanode.api.v2.TradingDataService.GetLatestMarketData:output_type -> datanode.api.v2.GetLatestMarketDataResponse + 86, // 615: datanode.api.v2.TradingDataService.ListLatestMarketData:output_type -> datanode.api.v2.ListLatestMarketDataResponse + 84, // 616: datanode.api.v2.TradingDataService.GetLatestMarketDepth:output_type -> datanode.api.v2.GetLatestMarketDepthResponse + 78, // 617: datanode.api.v2.TradingDataService.ObserveMarketsDepth:output_type -> datanode.api.v2.ObserveMarketsDepthResponse + 80, // 618: datanode.api.v2.TradingDataService.ObserveMarketsDepthUpdates:output_type -> datanode.api.v2.ObserveMarketsDepthUpdatesResponse + 82, // 619: datanode.api.v2.TradingDataService.ObserveMarketsData:output_type -> datanode.api.v2.ObserveMarketsDataResponse + 90, // 620: datanode.api.v2.TradingDataService.GetMarketDataHistoryByID:output_type -> datanode.api.v2.GetMarketDataHistoryByIDResponse + 94, // 621: datanode.api.v2.TradingDataService.ListTransfers:output_type -> datanode.api.v2.ListTransfersResponse + 99, // 622: datanode.api.v2.TradingDataService.GetTransfer:output_type -> datanode.api.v2.GetTransferResponse + 101, // 623: datanode.api.v2.TradingDataService.GetNetworkLimits:output_type -> datanode.api.v2.GetNetworkLimitsResponse + 109, // 624: datanode.api.v2.TradingDataService.ListCandleData:output_type -> datanode.api.v2.ListCandleDataResponse + 107, // 625: datanode.api.v2.TradingDataService.ObserveCandleData:output_type -> datanode.api.v2.ObserveCandleDataResponse + 104, // 626: datanode.api.v2.TradingDataService.ListCandleIntervals:output_type -> datanode.api.v2.ListCandleIntervalsResponse + 113, // 627: datanode.api.v2.TradingDataService.ListVotes:output_type -> datanode.api.v2.ListVotesResponse + 117, // 628: datanode.api.v2.TradingDataService.ObserveVotes:output_type -> datanode.api.v2.ObserveVotesResponse + 119, // 629: datanode.api.v2.TradingDataService.ListERC20MultiSigSignerAddedBundles:output_type -> datanode.api.v2.ListERC20MultiSigSignerAddedBundlesResponse + 125, // 630: datanode.api.v2.TradingDataService.ListERC20MultiSigSignerRemovedBundles:output_type -> datanode.api.v2.ListERC20MultiSigSignerRemovedBundlesResponse + 131, // 631: datanode.api.v2.TradingDataService.GetERC20ListAssetBundle:output_type -> datanode.api.v2.GetERC20ListAssetBundleResponse + 133, // 632: datanode.api.v2.TradingDataService.GetERC20SetAssetLimitsBundle:output_type -> datanode.api.v2.GetERC20SetAssetLimitsBundleResponse + 135, // 633: datanode.api.v2.TradingDataService.GetERC20WithdrawalApproval:output_type -> datanode.api.v2.GetERC20WithdrawalApprovalResponse + 137, // 634: datanode.api.v2.TradingDataService.GetLastTrade:output_type -> datanode.api.v2.GetLastTradeResponse + 139, // 635: datanode.api.v2.TradingDataService.ListTrades:output_type -> datanode.api.v2.ListTradesResponse + 143, // 636: datanode.api.v2.TradingDataService.ObserveTrades:output_type -> datanode.api.v2.ObserveTradesResponse + 145, // 637: datanode.api.v2.TradingDataService.GetOracleSpec:output_type -> datanode.api.v2.GetOracleSpecResponse + 147, // 638: datanode.api.v2.TradingDataService.ListOracleSpecs:output_type -> datanode.api.v2.ListOracleSpecsResponse + 149, // 639: datanode.api.v2.TradingDataService.ListOracleData:output_type -> datanode.api.v2.ListOracleDataResponse + 155, // 640: datanode.api.v2.TradingDataService.GetMarket:output_type -> datanode.api.v2.GetMarketResponse + 157, // 641: datanode.api.v2.TradingDataService.ListMarkets:output_type -> datanode.api.v2.ListMarketsResponse + 164, // 642: datanode.api.v2.TradingDataService.ListSuccessorMarkets:output_type -> datanode.api.v2.ListSuccessorMarketsResponse + 166, // 643: datanode.api.v2.TradingDataService.GetParty:output_type -> datanode.api.v2.GetPartyResponse + 168, // 644: datanode.api.v2.TradingDataService.ListParties:output_type -> datanode.api.v2.ListPartiesResponse + 172, // 645: datanode.api.v2.TradingDataService.ListPartiesProfiles:output_type -> datanode.api.v2.ListPartiesProfilesResponse + 177, // 646: datanode.api.v2.TradingDataService.ListMarginLevels:output_type -> datanode.api.v2.ListMarginLevelsResponse + 179, // 647: datanode.api.v2.TradingDataService.ObserveMarginLevels:output_type -> datanode.api.v2.ObserveMarginLevelsResponse + 184, // 648: datanode.api.v2.TradingDataService.ListRewards:output_type -> datanode.api.v2.ListRewardsResponse + 188, // 649: datanode.api.v2.TradingDataService.ListRewardSummaries:output_type -> datanode.api.v2.ListRewardSummariesResponse + 191, // 650: datanode.api.v2.TradingDataService.ListEpochRewardSummaries:output_type -> datanode.api.v2.ListEpochRewardSummariesResponse + 197, // 651: datanode.api.v2.TradingDataService.GetDeposit:output_type -> datanode.api.v2.GetDepositResponse + 199, // 652: datanode.api.v2.TradingDataService.ListDeposits:output_type -> datanode.api.v2.ListDepositsResponse + 203, // 653: datanode.api.v2.TradingDataService.GetWithdrawal:output_type -> datanode.api.v2.GetWithdrawalResponse + 205, // 654: datanode.api.v2.TradingDataService.ListWithdrawals:output_type -> datanode.api.v2.ListWithdrawalsResponse + 209, // 655: datanode.api.v2.TradingDataService.GetAsset:output_type -> datanode.api.v2.GetAssetResponse + 211, // 656: datanode.api.v2.TradingDataService.ListAssets:output_type -> datanode.api.v2.ListAssetsResponse + 216, // 657: datanode.api.v2.TradingDataService.ListLiquidityProvisions:output_type -> datanode.api.v2.ListLiquidityProvisionsResponse + 217, // 658: datanode.api.v2.TradingDataService.ListAllLiquidityProvisions:output_type -> datanode.api.v2.ListAllLiquidityProvisionsResponse + 224, // 659: datanode.api.v2.TradingDataService.ObserveLiquidityProvisions:output_type -> datanode.api.v2.ObserveLiquidityProvisionsResponse + 229, // 660: datanode.api.v2.TradingDataService.ListLiquidityProviders:output_type -> datanode.api.v2.ListLiquidityProvidersResponse + 231, // 661: datanode.api.v2.TradingDataService.ListPaidLiquidityFees:output_type -> datanode.api.v2.ListPaidLiquidityFeesResponse + 235, // 662: datanode.api.v2.TradingDataService.GetGovernanceData:output_type -> datanode.api.v2.GetGovernanceDataResponse + 237, // 663: datanode.api.v2.TradingDataService.ListGovernanceData:output_type -> datanode.api.v2.ListGovernanceDataResponse + 241, // 664: datanode.api.v2.TradingDataService.ObserveGovernance:output_type -> datanode.api.v2.ObserveGovernanceResponse + 243, // 665: datanode.api.v2.TradingDataService.ListDelegations:output_type -> datanode.api.v2.ListDelegationsResponse + 250, // 666: datanode.api.v2.TradingDataService.GetNetworkData:output_type -> datanode.api.v2.GetNetworkDataResponse + 252, // 667: datanode.api.v2.TradingDataService.GetNode:output_type -> datanode.api.v2.GetNodeResponse + 254, // 668: datanode.api.v2.TradingDataService.ListNodes:output_type -> datanode.api.v2.ListNodesResponse + 258, // 669: datanode.api.v2.TradingDataService.ListNodeSignatures:output_type -> datanode.api.v2.ListNodeSignaturesResponse + 262, // 670: datanode.api.v2.TradingDataService.GetEpoch:output_type -> datanode.api.v2.GetEpochResponse + 264, // 671: datanode.api.v2.TradingDataService.EstimateFee:output_type -> datanode.api.v2.EstimateFeeResponse + 266, // 672: datanode.api.v2.TradingDataService.EstimateMargin:output_type -> datanode.api.v2.EstimateMarginResponse + 342, // 673: datanode.api.v2.TradingDataService.EstimatePosition:output_type -> datanode.api.v2.EstimatePositionResponse + 268, // 674: datanode.api.v2.TradingDataService.ListNetworkParameters:output_type -> datanode.api.v2.ListNetworkParametersResponse + 270, // 675: datanode.api.v2.TradingDataService.GetNetworkParameter:output_type -> datanode.api.v2.GetNetworkParameterResponse + 275, // 676: datanode.api.v2.TradingDataService.ListCheckpoints:output_type -> datanode.api.v2.ListCheckpointsResponse + 279, // 677: datanode.api.v2.TradingDataService.GetStake:output_type -> datanode.api.v2.GetStakeResponse + 283, // 678: datanode.api.v2.TradingDataService.GetRiskFactors:output_type -> datanode.api.v2.GetRiskFactorsResponse + 285, // 679: datanode.api.v2.TradingDataService.ObserveEventBus:output_type -> datanode.api.v2.ObserveEventBusResponse + 287, // 680: datanode.api.v2.TradingDataService.ObserveLedgerMovements:output_type -> datanode.api.v2.ObserveLedgerMovementsResponse + 289, // 681: datanode.api.v2.TradingDataService.ListKeyRotations:output_type -> datanode.api.v2.ListKeyRotationsResponse + 293, // 682: datanode.api.v2.TradingDataService.ListEthereumKeyRotations:output_type -> datanode.api.v2.ListEthereumKeyRotationsResponse + 297, // 683: datanode.api.v2.TradingDataService.GetVegaTime:output_type -> datanode.api.v2.GetVegaTimeResponse + 300, // 684: datanode.api.v2.TradingDataService.GetProtocolUpgradeStatus:output_type -> datanode.api.v2.GetProtocolUpgradeStatusResponse + 302, // 685: datanode.api.v2.TradingDataService.ListProtocolUpgradeProposals:output_type -> datanode.api.v2.ListProtocolUpgradeProposalsResponse + 306, // 686: datanode.api.v2.TradingDataService.ListCoreSnapshots:output_type -> datanode.api.v2.ListCoreSnapshotsResponse + 311, // 687: datanode.api.v2.TradingDataService.GetMostRecentNetworkHistorySegment:output_type -> datanode.api.v2.GetMostRecentNetworkHistorySegmentResponse + 313, // 688: datanode.api.v2.TradingDataService.ListAllNetworkHistorySegments:output_type -> datanode.api.v2.ListAllNetworkHistorySegmentsResponse + 315, // 689: datanode.api.v2.TradingDataService.GetActiveNetworkHistoryPeerAddresses:output_type -> datanode.api.v2.GetActiveNetworkHistoryPeerAddressesResponse + 317, // 690: datanode.api.v2.TradingDataService.GetNetworkHistoryStatus:output_type -> datanode.api.v2.GetNetworkHistoryStatusResponse + 319, // 691: datanode.api.v2.TradingDataService.GetNetworkHistoryBootstrapPeers:output_type -> datanode.api.v2.GetNetworkHistoryBootstrapPeersResponse + 322, // 692: datanode.api.v2.TradingDataService.ListEntities:output_type -> datanode.api.v2.ListEntitiesResponse + 333, // 693: datanode.api.v2.TradingDataService.ListFundingPeriods:output_type -> datanode.api.v2.ListFundingPeriodsResponse + 337, // 694: datanode.api.v2.TradingDataService.ListFundingPeriodDataPoints:output_type -> datanode.api.v2.ListFundingPeriodDataPointsResponse + 329, // 695: datanode.api.v2.TradingDataService.ListFundingPayments:output_type -> datanode.api.v2.ListFundingPaymentsResponse + 324, // 696: datanode.api.v2.TradingDataService.GetPartyActivityStreak:output_type -> datanode.api.v2.GetPartyActivityStreakResponse + 348, // 697: datanode.api.v2.TradingDataService.GetCurrentReferralProgram:output_type -> datanode.api.v2.GetCurrentReferralProgramResponse + 354, // 698: datanode.api.v2.TradingDataService.ListReferralSets:output_type -> datanode.api.v2.ListReferralSetsResponse + 359, // 699: datanode.api.v2.TradingDataService.ListReferralSetReferees:output_type -> datanode.api.v2.ListReferralSetRefereesResponse + 361, // 700: datanode.api.v2.TradingDataService.GetReferralSetStats:output_type -> datanode.api.v2.GetReferralSetStatsResponse + 369, // 701: datanode.api.v2.TradingDataService.ListTeams:output_type -> datanode.api.v2.ListTeamsResponse + 371, // 702: datanode.api.v2.TradingDataService.ListTeamsStatistics:output_type -> datanode.api.v2.ListTeamsStatisticsResponse + 378, // 703: datanode.api.v2.TradingDataService.ListTeamMembersStatistics:output_type -> datanode.api.v2.ListTeamMembersStatisticsResponse + 386, // 704: datanode.api.v2.TradingDataService.ListTeamReferees:output_type -> datanode.api.v2.ListTeamRefereesResponse + 391, // 705: datanode.api.v2.TradingDataService.ListTeamRefereeHistory:output_type -> datanode.api.v2.ListTeamRefereeHistoryResponse + 393, // 706: datanode.api.v2.TradingDataService.GetFeesStats:output_type -> datanode.api.v2.GetFeesStatsResponse + 395, // 707: datanode.api.v2.TradingDataService.GetFeesStatsForParty:output_type -> datanode.api.v2.GetFeesStatsForPartyResponse + 397, // 708: datanode.api.v2.TradingDataService.GetCurrentVolumeDiscountProgram:output_type -> datanode.api.v2.GetCurrentVolumeDiscountProgramResponse + 399, // 709: datanode.api.v2.TradingDataService.GetVolumeDiscountStats:output_type -> datanode.api.v2.GetVolumeDiscountStatsResponse + 11, // 710: datanode.api.v2.TradingDataService.GetVestingBalancesSummary:output_type -> datanode.api.v2.GetVestingBalancesSummaryResponse + 9, // 711: datanode.api.v2.TradingDataService.GetPartyVestingStats:output_type -> datanode.api.v2.GetPartyVestingStatsResponse + 406, // 712: datanode.api.v2.TradingDataService.ObserveTransactionResults:output_type -> datanode.api.v2.ObserveTransactionResultsResponse + 408, // 713: datanode.api.v2.TradingDataService.EstimateTransferFee:output_type -> datanode.api.v2.EstimateTransferFeeResponse + 410, // 714: datanode.api.v2.TradingDataService.GetTotalTransferFeeDiscount:output_type -> datanode.api.v2.GetTotalTransferFeeDiscountResponse + 412, // 715: datanode.api.v2.TradingDataService.ListGames:output_type -> datanode.api.v2.ListGamesResponse + 422, // 716: datanode.api.v2.TradingDataService.ListPartyMarginModes:output_type -> datanode.api.v2.ListPartyMarginModesResponse + 428, // 717: datanode.api.v2.TradingDataService.GetTimeWeightedNotionalPosition:output_type -> datanode.api.v2.GetTimeWeightedNotionalPositionResponse + 430, // 718: datanode.api.v2.TradingDataService.ListAMMs:output_type -> datanode.api.v2.ListAMMsResponse + 434, // 719: datanode.api.v2.TradingDataService.EstimateAMMBounds:output_type -> datanode.api.v2.EstimateAMMBoundsResponse + 515, // 720: datanode.api.v2.TradingDataService.ExportNetworkHistory:output_type -> google.api.HttpBody + 339, // 721: datanode.api.v2.TradingDataService.Ping:output_type -> datanode.api.v2.PingResponse + 597, // [597:722] is the sub-list for method output_type + 472, // [472:597] is the sub-list for method input_type 472, // [472:472] is the sub-list for extension type_name 472, // [472:472] is the sub-list for extension extendee 0, // [0:472] is the sub-list for field type_name @@ -38078,6 +38337,30 @@ func file_data_node_api_v2_trading_data_proto_init() { return nil } } + file_data_node_api_v2_trading_data_proto_msgTypes[427].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EstimateAMMBoundsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_data_node_api_v2_trading_data_proto_msgTypes[428].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EstimateAMMBoundsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } file_data_node_api_v2_trading_data_proto_msgTypes[0].OneofWrappers = []interface{}{} file_data_node_api_v2_trading_data_proto_msgTypes[4].OneofWrappers = []interface{}{} @@ -38191,13 +38474,14 @@ func file_data_node_api_v2_trading_data_proto_init() { file_data_node_api_v2_trading_data_proto_msgTypes[419].OneofWrappers = []interface{}{} file_data_node_api_v2_trading_data_proto_msgTypes[421].OneofWrappers = []interface{}{} file_data_node_api_v2_trading_data_proto_msgTypes[423].OneofWrappers = []interface{}{} + file_data_node_api_v2_trading_data_proto_msgTypes[427].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_data_node_api_v2_trading_data_proto_rawDesc, NumEnums: 6, - NumMessages: 427, + NumMessages: 429, NumExtensions: 0, NumServices: 1, }, diff --git a/protos/data-node/api/v2/trading_data_grpc.pb.go b/protos/data-node/api/v2/trading_data_grpc.pb.go index b7900ec0b66..c776bc9ad10 100644 --- a/protos/data-node/api/v2/trading_data_grpc.pb.go +++ b/protos/data-node/api/v2/trading_data_grpc.pb.go @@ -576,6 +576,10 @@ type TradingDataServiceClient interface { // // Get a list of AMM or filter by market ID, party ID or AMM ID ListAMMs(ctx context.Context, in *ListAMMsRequest, opts ...grpc.CallOption) (*ListAMMsResponse, error) + // Estimate AMM bounds + // + // Get a list of AMMs or filter by market ID, party ID or AMM ID + EstimateAMMBounds(ctx context.Context, in *EstimateAMMBoundsRequest, opts ...grpc.CallOption) (*EstimateAMMBoundsResponse, error) // Export network history as CSV // // Export CSV table data from network history between two block heights. @@ -2120,6 +2124,15 @@ func (c *tradingDataServiceClient) ListAMMs(ctx context.Context, in *ListAMMsReq return out, nil } +func (c *tradingDataServiceClient) EstimateAMMBounds(ctx context.Context, in *EstimateAMMBoundsRequest, opts ...grpc.CallOption) (*EstimateAMMBoundsResponse, error) { + out := new(EstimateAMMBoundsResponse) + err := c.cc.Invoke(ctx, "/datanode.api.v2.TradingDataService/EstimateAMMBounds", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *tradingDataServiceClient) ExportNetworkHistory(ctx context.Context, in *ExportNetworkHistoryRequest, opts ...grpc.CallOption) (TradingDataService_ExportNetworkHistoryClient, error) { stream, err := c.cc.NewStream(ctx, &TradingDataService_ServiceDesc.Streams[16], "/datanode.api.v2.TradingDataService/ExportNetworkHistory", opts...) if err != nil { @@ -2718,6 +2731,10 @@ type TradingDataServiceServer interface { // // Get a list of AMM or filter by market ID, party ID or AMM ID ListAMMs(context.Context, *ListAMMsRequest) (*ListAMMsResponse, error) + // Estimate AMM bounds + // + // Get a list of AMMs or filter by market ID, party ID or AMM ID + EstimateAMMBounds(context.Context, *EstimateAMMBoundsRequest) (*EstimateAMMBoundsResponse, error) // Export network history as CSV // // Export CSV table data from network history between two block heights. @@ -3157,6 +3174,9 @@ func (UnimplementedTradingDataServiceServer) GetTimeWeightedNotionalPosition(con func (UnimplementedTradingDataServiceServer) ListAMMs(context.Context, *ListAMMsRequest) (*ListAMMsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListAMMs not implemented") } +func (UnimplementedTradingDataServiceServer) EstimateAMMBounds(context.Context, *EstimateAMMBoundsRequest) (*EstimateAMMBoundsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EstimateAMMBounds not implemented") +} func (UnimplementedTradingDataServiceServer) ExportNetworkHistory(*ExportNetworkHistoryRequest, TradingDataService_ExportNetworkHistoryServer) error { return status.Errorf(codes.Unimplemented, "method ExportNetworkHistory not implemented") } @@ -5425,6 +5445,24 @@ func _TradingDataService_ListAMMs_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _TradingDataService_EstimateAMMBounds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EstimateAMMBoundsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TradingDataServiceServer).EstimateAMMBounds(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/datanode.api.v2.TradingDataService/EstimateAMMBounds", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TradingDataServiceServer).EstimateAMMBounds(ctx, req.(*EstimateAMMBoundsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _TradingDataService_ExportNetworkHistory_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ExportNetworkHistoryRequest) if err := stream.RecvMsg(m); err != nil { @@ -5895,6 +5933,10 @@ var TradingDataService_ServiceDesc = grpc.ServiceDesc{ MethodName: "ListAMMs", Handler: _TradingDataService_ListAMMs_Handler, }, + { + MethodName: "EstimateAMMBounds", + Handler: _TradingDataService_EstimateAMMBounds_Handler, + }, { MethodName: "Ping", Handler: _TradingDataService_Ping_Handler, diff --git a/protos/sources/data-node/api/v2/trading_data.proto b/protos/sources/data-node/api/v2/trading_data.proto index 46f98d53feb..1fc4afda166 100644 --- a/protos/sources/data-node/api/v2/trading_data.proto +++ b/protos/sources/data-node/api/v2/trading_data.proto @@ -960,6 +960,13 @@ service TradingDataService { option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {tags: "AMMs"}; } + // Estimate AMM bounds + // + // Get a list of AMMs or filter by market ID, party ID or AMM ID + rpc EstimateAMMBounds(EstimateAMMBoundsRequest) returns (EstimateAMMBoundsResponse) { + option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {tags: "AMMs"}; + } + // Export network history as CSV // // Export CSV table data from network history between two block heights. @@ -5009,3 +5016,38 @@ message AMMEdge { // Cursor that can be used to fetch further pages. string cursor = 2; } + +message EstimateAMMBoundsRequest { + // Base price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + string base_price = 1; + // Upper price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + optional string upper_price = 2; + // Lower price of the AMM pool, the price is an integer, for example `123456` is a correctly + // formatted price of `1.23456` assuming market configured to 5 decimal places. + optional string lower_price = 3; + // Leverage at the upper price of the AMM pool. + optional string leverage_at_upper_price = 4; + // Leverage at the lower price of the AMM pool. + optional string leverage_at_lower_price = 5; + // Amount of the asset that the party is willing to commit to the AMM pool. + string commitment_amount = 6; + // Market ID to estimate the AMM for. + string market_id = 7; +} + +message EstimateAMMBoundsResponse { + // Theoretical volume at the top of the upper bound. + string position_size_at_upper = 1; + // Theoretical volume at the top of the lower bound. + string position_size_at_lower = 2; + // Loss of commitment at the upper bound. + string loss_on_commitment_at_upper = 3; + // Loss of commitment at the lower bound. + string loss_on_commitment_at_lower = 4; + // Estimated price above upper bound at which the commitment will be lost. + string liquidation_price_at_upper = 5; + // Estimated price below the lower bound at which the commitment will be lost. + string liquidation_price_at_lower = 6; +}