code.vegaprotocol.io/vega@v0.79.0/core/governance/engine_new_market_test.go

// 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 <http://www.gnu.org/licenses/>.

package governance_test

import (
	"context"
	"fmt"
	"testing"
	"time"

	"code.vegaprotocol.io/vega/core/datasource"
	dstypes "code.vegaprotocol.io/vega/core/datasource/common"
	dsdefinition "code.vegaprotocol.io/vega/core/datasource/definition"
	dserrors "code.vegaprotocol.io/vega/core/datasource/errors"
	"code.vegaprotocol.io/vega/core/datasource/external/signedoracle"
	"code.vegaprotocol.io/vega/core/events"
	"code.vegaprotocol.io/vega/core/governance"
	"code.vegaprotocol.io/vega/core/types"
	"code.vegaprotocol.io/vega/libs/num"
	"code.vegaprotocol.io/vega/libs/ptr"
	vgrand "code.vegaprotocol.io/vega/libs/rand"
	datapb "code.vegaprotocol.io/vega/protos/vega/data/v1"

	"github.com/golang/mock/gomock"
	"github.com/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestProposalForNewMarket(t *testing.T) {
	t.Run("Submitting a proposal for new market succeeds", testSubmittingProposalForNewMarketSucceeds)
	t.Run("Submitting a proposal for new capped market succeeds", testSubmittingProposalForNewCappedMarketSucceeds)
	t.Run("Submitting a proposal for invalid capped market fails", testSubmittingProposalForInvalidCappedMarketFails)
	t.Run("Submitting a proposal for new perps market succeeds", testSubmittingProposalForNewPerpsMarketSucceeds)
	t.Run("Submitting a proposal for new perps market succeeds 2", testSubmittingProposalForNewPerpsMarketWithCustomInitialTimeSucceeds)
	t.Run("Submitting a proposal for new perps market with initial time in past fails", testSubmittingProposalForNewPerpsMarketWithPastInitialTimeFails)
	t.Run("Submitting a proposal with internal time termination for new market succeeds", testSubmittingProposalWithInternalTimeTerminationForNewMarketSucceeds)
	t.Run("Submitting a proposal with internal time termination with `less than equal` condition fails", testSubmittingProposalWithInternalTimeTerminationWithLessThanEqualConditionForNewMarketFails)
	t.Run("Submitting a proposal with internal time settling for new market fails", testSubmittingProposalWithInternalTimeSettlingForNewMarketFails)
	t.Run("Submitting a proposal with empty settling data for marker market fails", testSubmittingProposalWithEmptySettlingDataForNewMarketFails)
	t.Run("Submitting a proposal with empty termination data for marker market fails", testSubmittingProposalWithEmptyTerminationDataForNewMarketFails)
	t.Run("Submitting a proposal with external source using internal time termination key for new market succeeds", testSubmittingProposalWithExternalWithInternalTimeTerminationKeyForNewMarketSucceeds)
	t.Run("Submitting a proposal with using internal time trigger termination fails", testSubmittingProposalWithInternalTimeTriggerTerminationFails)
	t.Run("Submitting a proposal with using internal time trigger settlement fails", testSubmittingProposalWithInternalTimeTriggerSettlementFails)
	t.Run("Submitting a duplicated proposal for new market fails", testSubmittingDuplicatedProposalForNewMarketFails)
	t.Run("Submitting a duplicated proposal with internal time termination for new market fails", testSubmittingDuplicatedProposalWithInternalTimeTerminationForNewMarketFails)
	t.Run("Submitting a proposal for new market with bad risk parameter fails", testSubmittingProposalForNewMarketWithBadRiskParameterFails)
	t.Run("Submitting a proposal for new market with internal time termination with bad risk parameter fails", testSubmittingProposalForNewMarketWithInternalTimeTerminationWithBadRiskParameterFails)
	t.Run("Submitting a proposal for a ne market without disposal slippage range fails", testSubmittingProposalWithoutDisposalSlippageFails)

	t.Run("Rejecting a proposal for new market succeeds", testRejectingProposalForNewMarketSucceeds)

	t.Run("Voting for a new market proposal succeeds", testVotingForNewMarketProposalSucceeds)
	t.Run("Voting with a majority of 'yes' makes the new market proposal passed", testVotingWithMajorityOfYesMakesNewMarketProposalPassed)
	t.Run("Voting with a majority of 'no' makes the new market proposal declined", testVotingWithMajorityOfNoMakesNewMarketProposalDeclined)
	t.Run("Voting with insufficient participation makes the new market proposal declined", testVotingWithInsufficientParticipationMakesNewMarketProposalDeclined)
	t.Run("Invalid combination of decimals for market", testInvalidDecimalPlace)
}

func TestProposalForSuccessorMarket(t *testing.T) {
	t.Run("Submitting a proposal for fully defined successor market succeeds", testSubmittingProposalForFullSuccessorMarketSucceeds)

	t.Run("Reject successor markets with an invalid insurance pool fraction", testRejectSuccessorInvalidInsurancePoolFraction)
	t.Run("Reject successor market proposal if the product is incompatible", testRejectSuccessorProductMismatch)
	t.Run("Reject successor market if the parent market does not exist", testRejectSuccessorNoParent)

	t.Run("Remove proposals for an already succeeded market", testRemoveSuccessorsForSucceeded)
	t.Run("Remove proposals for an already succeeded market on tick", testRemoveSuccessorsForRejectedMarket)
}

func testSubmittingProposalForInvalidCappedMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForCapped(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &types.FutureCap{
		MaxPrice:            num.UintZero(),
		Binary:              true,
		FullyCollateralised: true,
	})

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	require.Nil(t, toSubmit)

	// another failed scenario is when the max price doesn't respect the tick size
	proposal = eng.newProposalForCapped(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &types.FutureCap{
		MaxPrice:            num.NewUint(1234),
		Binary:              true,
		FullyCollateralised: true,
	})
	nmp := proposal.Terms.GetNewMarket()
	nmp.Changes.TickSize = num.NewUint(10)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err = eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalForNewCappedMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForCapped(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &types.FutureCap{
		MaxPrice:            num.NewUint(1000),
		Binary:              true,
		FullyCollateralised: true,
	})

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())

	// same as above, but with a tick size that is non-zero
	proposal = eng.newProposalForCapped(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &types.FutureCap{
		MaxPrice:            num.NewUint(1000),
		Binary:              true,
		FullyCollateralised: true,
	})
	nmp := proposal.Terms.GetNewMarket()
	nmp.Changes.TickSize = num.NewUint(10)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err = eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testSubmittingProposalForNewMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testRemoveSuccessorsForRejectedMarket(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(.5),
	}
	// add 3 proposals for the same parent
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	eng.markets.EXPECT().IsSucceeded(suc.ParentID).Times(3).Return(false)
	filter, binding := produceTimeTriggeredDataSourceSpec(now.Add(3 * 48 * time.Hour))
	enact := now.Add(24 * time.Hour)
	proposals := []types.Proposal{
		eng.newProposalForSuccessorMarket(party.Id, enact, filter, binding, true, &suc),
		eng.newProposalForSuccessorMarket(party.Id, enact, filter, binding, true, &suc),
		eng.newProposalForNewMarket(party.Id, enact, filter, binding, true), // non successor just because
		eng.newProposalForSuccessorMarket(party.Id, enact, filter, binding, true, &suc),
	}
	first := proposals[0]
	pFuture := first.NewMarket().Changes.GetFuture()
	eng.ensureAllAssetEnabled(t)
	for _, p := range proposals {
		eng.expectOpenProposalEvent(t, party.Id, p.ID)
	}
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(6).Return(
		types.Market{
			TradableInstrument: &types.TradableInstrument{
				Instrument: &types.Instrument{
					Product: &types.InstrumentFuture{
						Future: &types.Future{
							SettlementAsset: pFuture.Future.SettlementAsset,
							QuoteName:       pFuture.Future.SettlementAsset,
						},
					},
				},
			},
		}, true)

	// submit all proposals
	for _, p := range proposals {
		toSubmit, err := eng.submitProposal(t, p)

		// then
		require.NoError(t, err)
		require.NotNil(t, toSubmit)
		assert.True(t, toSubmit.IsNewMarket())
		require.NotNil(t, toSubmit.NewMarket().Market())
	}
	// all proposals will be in the active proposals slice, so let's make sure all of them are removed
	for _, p := range proposals {
		if p.IsSuccessorMarket() {
			eng.markets.EXPECT().GetMarketState(p.ID).Times(1).Return(types.MarketStateRejected, errors.New("foo"))
		}
	}
	expState := types.ProposalStateRejected
	expError := types.ProposalErrorInvalidSuccessorMarket
	eng.broker.EXPECT().Send(gomock.Any()).AnyTimes().Do(func(evt events.Event) {
		pe, ok := evt.(*events.Proposal)
		require.True(t, ok)
		prop := pe.Proposal()
		require.Equal(t, expState, prop.State)
		require.NotNil(t, prop.Reason)
		require.EqualValues(t, expError, *prop.Reason)
	})
	eng.OnTick(context.Background(), now.Add(time.Second))
}

func testRemoveSuccessorsForSucceeded(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(.5),
	}
	// add 3 proposals for the same parent
	eng.markets.EXPECT().IsSucceeded(suc.ParentID).Times(3).Return(false)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	filter, binding := produceTimeTriggeredDataSourceSpec(now.Add(3 * 48 * time.Hour))
	proposals := []types.Proposal{
		eng.newProposalForSuccessorMarket(party.Id, now, filter, binding, true, &suc),
		eng.newProposalForSuccessorMarket(party.Id, now, filter, binding, true, &suc),
		eng.newProposalForNewMarket(party.Id, now, filter, binding, true), // non successor just because
		eng.newProposalForSuccessorMarket(party.Id, now, filter, binding, true, &suc),
	}
	first := proposals[0]
	pFuture := first.NewMarket().Changes.GetFuture()
	eng.ensureAllAssetEnabled(t)
	for _, p := range proposals {
		eng.expectOpenProposalEvent(t, party.Id, p.ID)
	}
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(6).Return(
		types.Market{
			TradableInstrument: &types.TradableInstrument{
				Instrument: &types.Instrument{
					Product: &types.InstrumentFuture{
						Future: &types.Future{
							SettlementAsset: pFuture.Future.SettlementAsset,
							QuoteName:       pFuture.Future.SettlementAsset,
						},
					},
				},
			},
		}, true)

	// submit all proposals
	for _, p := range proposals {
		toSubmit, err := eng.submitProposal(t, p)

		// then
		require.NoError(t, err)
		require.NotNil(t, toSubmit)
		assert.True(t, toSubmit.IsNewMarket())
		require.NotNil(t, toSubmit.NewMarket().Market())
	}
	// all proposals will be in the active proposals slice, so let's make sure all of them are removed
	first.State = types.ProposalStateEnacted
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)
	eng.FinaliseEnactment(context.Background(), &first)
}

func testSubmittingProposalForFullSuccessorMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(.5),
	}
	eng.markets.EXPECT().IsSucceeded(suc.ParentID).Times(1).Return(false)
	filter, binding := produceTimeTriggeredDataSourceSpec(now.Add(3 * 48 * time.Hour))
	proposal := eng.newProposalForSuccessorMarket(party.Id, now, filter, binding, true, &suc)
	// returns a pointer directly to the change, but reassign just in case it doesn't
	nm := proposal.NewMarket()
	// ensure price monitoring params are set
	if nm.Changes.PriceMonitoringParameters == nil {
		nm.Changes.PriceMonitoringParameters = &types.PriceMonitoringParameters{
			Triggers: []*types.PriceMonitoringTrigger{
				{
					Horizon:          5,
					HorizonDec:       num.DecimalFromFloat(5),
					Probability:      num.DecimalFromFloat(.95),
					AuctionExtension: 1,
				},
			},
		}
	}
	// ensure risk model params are set
	if nm.Changes.RiskParameters == nil {
		nm.Changes.RiskParameters = &types.NewMarketConfigurationSimple{
			Simple: &types.SimpleModelParams{},
		}
	}
	proposal.Terms.Change = &types.ProposalTermsNewMarket{
		NewMarket: nm,
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)
	// GetMarket will be called in validateChange & intoSubmit
	pFuture := proposal.NewMarket().Changes.GetFuture()
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(2).Return(
		types.Market{
			TradableInstrument: &types.TradableInstrument{
				Instrument: &types.Instrument{
					Product: &types.InstrumentFuture{
						Future: &types.Future{
							SettlementAsset: pFuture.Future.SettlementAsset,
							QuoteName:       pFuture.Future.SettlementAsset,
						},
					},
				},
			},
		}, true)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testRejectSuccessorInvalidInsurancePoolFraction(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(5), // out of range 0-1
	}
	proposal := eng.newProposalForSuccessorMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &suc)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidSuccessorMarket)
	// GetMarket will only be called once, the second call will never happen due to the insurance pool fraction being invalid
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(1).Return(types.Market{}, true) // market can be empty, we won't access the settlement/quote stuff

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	require.Nil(t, toSubmit)
}

func testRejectSuccessorProductMismatch(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(0),
	}
	proposal := eng.newProposalForSuccessorMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, false, &suc)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidSuccessorMarket)
	// GetMarket will only be called once, the second call will never happen due to the product mismatch
	fProduct := proposal.NewMarket().Changes.GetFuture()
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(1).Return(
		types.Market{
			TradableInstrument: &types.TradableInstrument{
				Instrument: &types.Instrument{
					Product: &types.InstrumentFuture{
						Future: &types.Future{
							SettlementAsset: fmt.Sprintf("not%s", fProduct.Future.SettlementAsset),
							QuoteName:       fmt.Sprintf("not%s", fProduct.Future.QuoteName),
						},
					},
				},
			},
		}, true)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	require.Nil(t, toSubmit)
}

func testRejectSuccessorNoParent(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	suc := types.SuccessorConfig{
		ParentID:              "parentID",
		InsurancePoolFraction: num.DecimalFromFloat(0),
	}
	proposal := eng.newProposalForSuccessorMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true, &suc)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidSuccessorMarket)
	// only called once, validateChange already flags this error (missing parent)
	eng.markets.EXPECT().GetMarket(suc.ParentID, true).Times(1).Return(types.Market{}, false)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithInternalTimeTerminationForNewMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, false)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testSubmittingProposalWithInternalTimeSettlingForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset: "VUSD",
									QuoteName:       "VUSD",
									DataSourceSpecForSettlementData: *datasource.NewDefinition(
										datasource.ContentTypeOracle,
									).SetTimeTriggerConditionConfig(
										[]*dstypes.SpecCondition{
											{
												Operator: datapb.Condition_OPERATOR_GREATER_THAN_OR_EQUAL,
												Value:    "0",
											},
										},
									),
									DataSourceSpecForTradingTermination: *datasource.NewDefinition(
										datasource.ContentTypeOracle,
									).SetTimeTriggerConditionConfig(
										[]*dstypes.SpecCondition{
											{
												Operator: datapb.Condition_OPERATOR_GREATER_THAN_OR_EQUAL,
												Value:    fmt.Sprintf("%d", tm.UnixNano()),
											},
										}),
									DataSourceSpecBinding: termBinding,
								},
							},
						},
						RiskParameters: &types.NewMarketConfigurationLogNormal{
							LogNormal: &types.LogNormalRiskModel{
								RiskAversionParameter: num.DecimalFromFloat(0.01),
								Tau:                   num.DecimalFromFloat(0.00011407711613050422),
								Params: &types.LogNormalModelParams{
									Mu:    num.DecimalZero(),
									R:     num.DecimalFromFloat(0.016),
									Sigma: num.DecimalFromFloat(0.09),
								},
							},
						},
						Metadata:      []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces: 0,
						LiquiditySLAParameters: &types.LiquiditySLAParams{
							PriceRange: num.DecimalFromFloat(0.95),
						},
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, governance.ErrSettlementWithInternalDataSourceIsNotAllowed)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithEmptySettlingDataForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset:                     "VUSD",
									QuoteName:                           "VUSD",
									DataSourceSpecForSettlementData:     dsdefinition.Definition{},
									DataSourceSpecForTradingTermination: dsdefinition.Definition{},
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters: &types.NewMarketConfigurationLogNormal{
							LogNormal: &types.LogNormalRiskModel{
								RiskAversionParameter: num.DecimalFromFloat(0.01),
								Tau:                   num.DecimalFromFloat(0.00011407711613050422),
								Params: &types.LogNormalModelParams{
									Mu:    num.DecimalZero(),
									R:     num.DecimalFromFloat(0.016),
									Sigma: num.DecimalFromFloat(0.09),
								},
							},
						},
						Metadata:      []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces: 0,
						LiquiditySLAParameters: &types.LiquiditySLAParams{
							PriceRange: num.DecimalFromFloat(0.95),
						},
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, governance.ErrMissingDataSourceSpecForSettlementData)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithEmptyTerminationDataForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset: "VUSD",
									QuoteName:       "VUSD",
									DataSourceSpecForSettlementData: *datasource.NewDefinition(
										datasource.ContentTypeInternalTimeTermination,
									).SetTimeTriggerConditionConfig(
										[]*dstypes.SpecCondition{
											{
												Operator: datapb.Condition_OPERATOR_GREATER_THAN_OR_EQUAL,
												Value:    "0",
											},
										},
									),
									DataSourceSpecForTradingTermination: dsdefinition.Definition{},
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters: &types.NewMarketConfigurationLogNormal{
							LogNormal: &types.LogNormalRiskModel{
								RiskAversionParameter: num.DecimalFromFloat(0.01),
								Tau:                   num.DecimalFromFloat(0.00011407711613050422),
								Params: &types.LogNormalModelParams{
									Mu:    num.DecimalZero(),
									R:     num.DecimalFromFloat(0.016),
									Sigma: num.DecimalFromFloat(0.09),
								},
							},
						},
						Metadata:      []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces: 0,
						LiquiditySLAParameters: &types.LiquiditySLAParams{
							PriceRange: num.DecimalFromFloat(0.95),
						},
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, governance.ErrMissingDataSourceSpecForTradingTermination)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithInternalTimeTerminationWithLessThanEqualConditionForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	settl := datasource.NewDefinition(
		datasource.ContentTypeOracle,
	).SetOracleConfig(
		&signedoracle.SpecConfiguration{
			Signers: []*dstypes.Signer{dstypes.CreateSignerFromString("0xDEADBEEF", dstypes.SignerTypePubKey)},
			Filters: []*dstypes.SpecFilter{
				{
					Key: &dstypes.SpecPropertyKey{
						Name: "prices.ETH.value",
						Type: datapb.PropertyKey_TYPE_INTEGER,
					},
					Conditions: []*dstypes.SpecCondition{
						{
							Operator: datapb.Condition_OPERATOR_GREATER_THAN_OR_EQUAL,
							Value:    "0",
						},
					},
				},
			},
		},
	)

	term := datasource.NewDefinition(
		datasource.ContentTypeOracle,
	).SetTimeTriggerConditionConfig(
		[]*dstypes.SpecCondition{
			{
				Operator: datapb.Condition_OPERATOR_LESS_THAN,
				Value:    fmt.Sprintf("%d", tm.UnixNano()),
			},
		})

	riskParameters := types.NewMarketConfigurationLogNormal{
		LogNormal: &types.LogNormalRiskModel{
			RiskAversionParameter: num.DecimalFromFloat(0.01),
			Tau:                   num.DecimalFromFloat(0.00011407711613050422),
			Params: &types.LogNormalModelParams{
				Mu:    num.DecimalZero(),
				R:     num.DecimalFromFloat(0.016),
				Sigma: num.DecimalFromFloat(0.09),
			},
		},
	}

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset:                     "VUSD",
									QuoteName:                           "VUSD",
									DataSourceSpecForSettlementData:     *settl,
									DataSourceSpecForTradingTermination: *term,
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters: &riskParameters,
						Metadata:       []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces:  0,
						LiquiditySLAParameters: &types.LiquiditySLAParams{
							PriceRange: num.DecimalFromFloat(0.95),
						},
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, dserrors.ErrDataSourceSpecHasInvalidTimeCondition)
	require.Nil(t, toSubmit)

	term = datasource.NewDefinition(
		datasource.ContentTypeOracle,
	).SetTimeTriggerConditionConfig(
		[]*dstypes.SpecCondition{
			{
				Operator: datapb.Condition_OPERATOR_LESS_THAN_OR_EQUAL,
				Value:    fmt.Sprintf("%d", tm.UnixNano()),
			},
		})

	proposal = types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset:                     "VUSD",
									QuoteName:                           "VUSD",
									DataSourceSpecForSettlementData:     *settl,
									DataSourceSpecForTradingTermination: *term,
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters: &riskParameters,
						Metadata:       []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces:  0,
						LiquiditySLAParameters: &types.LiquiditySLAParams{
							PriceRange: num.DecimalFromFloat(0.95),
						},
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err = eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, dserrors.ErrDataSourceSpecHasInvalidTimeCondition)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithExternalWithInternalTimeTerminationKeyForNewMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	filter, binding := produceTimeTriggeredDataSourceSpec(now.Add(3 * 48 * time.Hour))
	proposal := eng.newProposalForNewMarket(party.Id, now.Add(2*time.Hour), filter, binding, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testSubmittingProposalWithInternalTimeTriggerTerminationFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	settl := datasource.NewDefinition(
		datasource.ContentTypeOracle,
	).SetOracleConfig(
		&signedoracle.SpecConfiguration{
			Signers: []*dstypes.Signer{dstypes.CreateSignerFromString("0xDEADBEEF", dstypes.SignerTypePubKey)},
			Filters: []*dstypes.SpecFilter{
				{
					Key: &dstypes.SpecPropertyKey{
						Name: "prices.ETH.value",
						Type: datapb.PropertyKey_TYPE_INTEGER,
					},
					Conditions: []*dstypes.SpecCondition{
						{
							Operator: datapb.Condition_OPERATOR_GREATER_THAN_OR_EQUAL,
							Value:    "0",
						},
					},
				},
			},
		},
	)

	term := datasource.NewDefinition(
		datasource.ContentTypeInternalTimeTriggerTermination,
	).SetTimeTriggerConditionConfig(
		[]*dstypes.SpecCondition{
			{
				Operator: datapb.Condition_OPERATOR_GREATER_THAN,
				Value:    fmt.Sprintf("%d", tm.UnixNano()),
			},
		})

	riskParameters := types.NewMarketConfigurationLogNormal{
		LogNormal: &types.LogNormalRiskModel{
			RiskAversionParameter: num.DecimalFromFloat(0.01),
			Tau:                   num.DecimalFromFloat(0.00011407711613050422),
			Params: &types.LogNormalModelParams{
				Mu:    num.DecimalZero(),
				R:     num.DecimalFromFloat(0.016),
				Sigma: num.DecimalFromFloat(0.09),
			},
		},
	}

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset:                     "VUSD",
									QuoteName:                           "VUSD",
									DataSourceSpecForSettlementData:     *settl,
									DataSourceSpecForTradingTermination: *term,
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters:          &riskParameters,
						Metadata:                []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces:           0,
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	// expect
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, governance.ErrInternalTimeTriggerForFuturesInNotAllowed)
	require.Nil(t, toSubmit)
}

func testSubmittingProposalWithInternalTimeTriggerSettlementFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	now := eng.tsvc.GetTimeNow().Add(2 * time.Hour)
	id := eng.newProposalID()
	tm := now.Add(time.Hour * 24 * 365)
	_, termBinding := produceTimeTriggeredDataSourceSpec(tm)

	settl := datasource.NewDefinition(
		datasource.ContentTypeInternalTimeTriggerTermination,
	).SetTimeTriggerConditionConfig(
		[]*dstypes.SpecCondition{
			{
				Operator: datapb.Condition_OPERATOR_GREATER_THAN,
				Value:    fmt.Sprintf("%d", tm.UnixNano()),
			},
		})

	term := datasource.NewDefinition(
		datasource.ContentTypeOracle,
	).SetTimeTriggerConditionConfig(
		[]*dstypes.SpecCondition{
			{
				Operator: datapb.Condition_OPERATOR_LESS_THAN,
				Value:    fmt.Sprintf("%d", tm.UnixNano()),
			},
		})

	riskParameters := types.NewMarketConfigurationLogNormal{
		LogNormal: &types.LogNormalRiskModel{
			RiskAversionParameter: num.DecimalFromFloat(0.01),
			Tau:                   num.DecimalFromFloat(0.00011407711613050422),
			Params: &types.LogNormalModelParams{
				Mu:    num.DecimalZero(),
				R:     num.DecimalFromFloat(0.016),
				Sigma: num.DecimalFromFloat(0.09),
			},
		},
	}

	proposal := types.Proposal{
		ID:        id,
		Reference: "ref-" + id,
		Party:     party.Id,
		State:     types.ProposalStateOpen,
		Terms: &types.ProposalTerms{
			ClosingTimestamp:    now.Add(48 * time.Hour).Unix(),
			EnactmentTimestamp:  now.Add(2 * 48 * time.Hour).Unix(),
			ValidationTimestamp: now.Add(1 * time.Hour).Unix(),
			Change: &types.ProposalTermsNewMarket{
				NewMarket: &types.NewMarket{
					Changes: &types.NewMarketConfiguration{
						Instrument: &types.InstrumentConfiguration{
							Name: "June 2020 GBP vs VUSD future",
							Code: "CRYPTO:GBPVUSD/JUN20",
							Product: &types.InstrumentConfigurationFuture{
								Future: &types.FutureProduct{
									SettlementAsset:                     "VUSD",
									QuoteName:                           "VUSD",
									DataSourceSpecForSettlementData:     *settl,
									DataSourceSpecForTradingTermination: *term,
									DataSourceSpecBinding:               termBinding,
								},
							},
						},
						RiskParameters:          &riskParameters,
						Metadata:                []string{"asset_class:fx/crypto", "product:futures"},
						DecimalPlaces:           0,
						LinearSlippageFactor:    num.DecimalFromFloat(0.1),
						QuadraticSlippageFactor: num.DecimalFromFloat(0.1),
						LiquidationStrategy: &types.LiquidationStrategy{
							DisposalTimeStep:    10 * time.Second,
							DisposalFraction:    num.DecimalFromFloat(0.1),
							FullDisposalSize:    20,
							MaxFractionConsumed: num.DecimalFromFloat(0.01),
							DisposalSlippage:    num.DecimalFromFloat(0.1),
						},
						TickSize: num.UintOne(),
					},
				},
			},
		},
		Rationale: &types.ProposalRationale{
			Description: "some description",
		},
	}

	// setup
	eng.ensureAllAssetEnabled(t)
	// expect
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidFutureProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	assert.Error(t, err, governance.ErrInternalTimeTriggerForFuturesInNotAllowed)
	require.Nil(t, toSubmit)
}

func testSubmittingDuplicatedProposalForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(party, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureTokenBalanceForParty(t, party, 1000)
	eng.ensureAllAssetEnabled(t)

	// expect
	eng.expectOpenProposalEvent(t, party, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	duplicatedProposal := proposal
	duplicatedProposal.Reference = "this-is-a-copy"

	// when
	_, err = eng.submitProposal(t, duplicatedProposal)

	// then
	require.Error(t, err)
	assert.EqualError(t, governance.ErrProposalIsDuplicate, err.Error())

	// given
	duplicatedProposal = proposal
	duplicatedProposal.State = types.ProposalStatePassed

	// when
	_, err = eng.submitProposal(t, duplicatedProposal)

	// then
	require.Error(t, err)
	assert.EqualError(t, governance.ErrProposalIsDuplicate, err.Error(), "reject attempt to change state indirectly")
}

func testSubmittingDuplicatedProposalWithInternalTimeTerminationForNewMarketFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(party, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, false)

	// setup
	eng.ensureTokenBalanceForParty(t, party, 1000)
	eng.ensureAllAssetEnabled(t)

	// expect
	eng.expectOpenProposalEvent(t, party, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	duplicatedProposal := proposal
	duplicatedProposal.Reference = "this-is-a-copy"

	// when
	_, err = eng.submitProposal(t, duplicatedProposal)

	// then
	require.Error(t, err)
	assert.EqualError(t, governance.ErrProposalIsDuplicate, err.Error())

	// given
	duplicatedProposal = proposal
	duplicatedProposal.State = types.ProposalStatePassed

	// when
	_, err = eng.submitProposal(t, duplicatedProposal)

	// then
	require.Error(t, err)
	assert.EqualError(t, governance.ErrProposalIsDuplicate, err.Error(), "reject attempt to change state indirectly")
}

func testSubmittingProposalForNewMarketWithBadRiskParameterFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 1)
	eng.ensureAllAssetEnabled(t)

	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)
	proposal.Terms.GetNewMarket().Changes.RiskParameters = &types.NewMarketConfigurationLogNormal{
		LogNormal: &types.LogNormalRiskModel{
			Params: nil, // it's nil by zero value, but eh, let's show that's what we test
		},
	}

	// setup
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	assert.Contains(t, err.Error(), "invalid risk parameter")
}

func testSubmittingProposalForNewMarketWithInternalTimeTerminationWithBadRiskParameterFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 1)
	eng.ensureAllAssetEnabled(t)

	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, false)
	proposal.Terms.GetNewMarket().Changes.RiskParameters = &types.NewMarketConfigurationLogNormal{
		LogNormal: &types.LogNormalRiskModel{
			Params: nil, // it's nil by zero value, but eh, let's show that's what we test
		},
	}

	// setup
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	assert.Contains(t, err.Error(), "invalid risk parameter")
}

func testSubmittingProposalWithoutDisposalSlippageFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	// given
	party := eng.newValidParty("a-valid-party", 1)
	eng.ensureAllAssetEnabled(t)

	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, false)
	proposal.Terms.GetNewMarket().Changes.LiquidationStrategy = &types.LiquidationStrategy{
		DisposalTimeStep:    time.Second * 10,
		DisposalFraction:    num.DecimalFromFloat(0.2),
		FullDisposalSize:    10,
		MaxFractionConsumed: num.DecimalFromFloat(0.5),
	}

	// setup
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	assert.Contains(t, err.Error(), "liquidation strategy must specify a disposal slippage range > 0")
}

func testOutOfRangeRiskParamFail(t *testing.T, lnm *types.LogNormalRiskModel) {
	t.Helper()
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 1)
	eng.ensureAllAssetEnabled(t)

	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)
	proposal.Terms.GetNewMarket().Changes.RiskParameters = &types.NewMarketConfigurationLogNormal{LogNormal: lnm}

	// setup
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.Error(t, err)
	assert.Contains(t, err.Error(), "invalid risk parameter")
}

func TestSubmittingProposalForNewMarketWithOutOfRangeRiskParameterFails(t *testing.T) {
	lnm := &types.LogNormalRiskModel{}
	lnm.RiskAversionParameter = num.DecimalFromFloat(1e-8 - 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.RiskAversionParameter = num.DecimalFromFloat(1e1 + 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.RiskAversionParameter = num.DecimalFromFloat(1e-6)
	lnm.Tau = num.DecimalFromFloat(1e-8 - 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Tau = num.DecimalFromFloat(1 + 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Tau = num.DecimalOne()
	lnm.Params = &types.LogNormalModelParams{}
	lnm.Params.Mu = num.DecimalFromFloat(-1e-6 - 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.Mu = num.DecimalFromFloat(1e-6 + 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.Mu = num.DecimalFromFloat(0.0)
	lnm.Params.R = num.DecimalFromFloat(-1 - 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.R = num.DecimalFromFloat(1 + 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.R = num.DecimalFromFloat(0.0)
	lnm.Params.Sigma = num.DecimalFromFloat(1e-3 - 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.Sigma = num.DecimalFromFloat(50 + 1e-12)
	testOutOfRangeRiskParamFail(t, lnm)
	lnm.Params.Sigma = num.DecimalFromFloat(1.0)

	// now all risk params are valid
	eng := getTestEngine(t, time.Now())

	// given
	party := eng.newValidParty("a-valid-party", 1)
	eng.ensureAllAssetEnabled(t)

	proposal := eng.newProposalForNewMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)
	proposal.Terms.GetNewMarket().Changes.RiskParameters = &types.NewMarketConfigurationLogNormal{LogNormal: lnm}

	// setup
	eng.broker.EXPECT().Send(gomock.Any()).Times(1)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
}

func testRejectingProposalForNewMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	party := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(party, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.ensureTokenBalanceForParty(t, party, 10000)

	// expect
	eng.expectOpenProposalEvent(t, party, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)

	// expect
	eng.expectRejectedProposalEvent(t, party, proposal.ID, types.ProposalErrorCouldNotInstantiateMarket)

	// when
	err = eng.RejectProposal(context.Background(), toSubmit.Proposal(), types.ProposalErrorCouldNotInstantiateMarket, assert.AnError)

	// then
	require.NoError(t, err)

	// when
	// Just one more time to make sure it was removed from proposals.
	err = eng.RejectProposal(context.Background(), toSubmit.Proposal(), types.ProposalErrorCouldNotInstantiateMarket, assert.AnError)

	// then
	assert.EqualError(t, err, governance.ErrProposalDoesNotExist.Error())
}

func testVotingForNewMarketProposalSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	proposer := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(proposer, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.ensureTokenBalanceForParty(t, proposer, 1)

	// expect
	eng.expectOpenProposalEvent(t, proposer, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	voter := vgrand.RandomStr(5)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 1)

	// expect
	eng.expectVoteEvent(t, voter, proposal.ID)

	// when
	err = eng.addYesVote(t, voter, proposal.ID)

	// then
	require.NoError(t, err)
}

func testVotingWithMajorityOfYesMakesNewMarketProposalPassed(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// when
	proposer := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(proposer, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureStakingAssetTotalSupply(t, 9)
	eng.ensureAllAssetEnabled(t)
	eng.ensureTokenBalanceForParty(t, proposer, 1)

	// expect
	eng.expectOpenProposalEvent(t, proposer, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	voter1 := vgrand.RandomStr(5)

	// setup
	eng.ensureTokenBalanceForParty(t, voter1, 7)

	// expect
	eng.expectVoteEvent(t, voter1, proposal.ID)

	// then
	err = eng.addYesVote(t, voter1, proposal.ID)

	// then
	require.NoError(t, err)

	// given
	afterClosing := time.Unix(proposal.Terms.ClosingTimestamp, 0).Add(time.Second)

	// setup
	eng.ensureTokenBalanceForParty(t, voter1, 7)

	// expect
	eng.expectPassedProposalEvent(t, proposal.ID)
	eng.expectTotalGovernanceTokenFromVoteEvents(t, "1", "7")
	eng.expectGetMarketState(t, proposal.ID)

	// when
	eng.OnTick(context.Background(), afterClosing)

	// given
	voter2 := vgrand.RandomStr(5)

	// when
	err = eng.addNoVote(t, voter2, proposal.ID)

	// then
	require.Error(t, err)
	assert.EqualError(t, err, governance.ErrProposalNotOpenForVotes.Error())

	// given
	afterEnactment := time.Unix(proposal.Terms.EnactmentTimestamp, 0).Add(time.Second)

	// when
	// no calculations, no state change, simply removed from governance engine
	toBeEnacted, _ := eng.OnTick(context.Background(), afterEnactment)

	// then
	require.Len(t, toBeEnacted, 1)
	assert.Equal(t, proposal.ID, toBeEnacted[0].Proposal().ID)

	// when
	err = eng.addNoVote(t, voter2, proposal.ID)

	// then
	require.Error(t, err)
	assert.EqualError(t, err, governance.ErrProposalDoesNotExist.Error())
}

func testVotingWithMajorityOfNoMakesNewMarketProposalDeclined(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	proposer := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(proposer, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.ensureStakingAssetTotalSupply(t, 200)
	eng.ensureTokenBalanceForParty(t, proposer, 100)

	// expect
	eng.expectOpenProposalEvent(t, proposer, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	voter := vgrand.RandomStr(5)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 100)

	// expect
	eng.expectVoteEvent(t, voter, proposal.ID)

	// when
	err = eng.addYesVote(t, voter, proposal.ID)

	// then
	require.NoError(t, err)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 100)

	// setup
	eng.expectVoteEvent(t, voter, proposal.ID)

	// when
	err = eng.addNoVote(t, voter, proposal.ID)

	// then
	require.NoError(t, err)

	// given
	afterClosing := time.Unix(proposal.Terms.ClosingTimestamp, 0).Add(time.Second)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 100)

	// expect
	eng.expectDeclinedProposalEvent(t, proposal.ID, types.ProposalErrorMajorityThresholdNotReached)
	eng.expectTotalGovernanceTokenFromVoteEvents(t, "1", "100")
	eng.expectGetMarketState(t, proposal.ID)

	// when
	_, voteClosed := eng.OnTick(context.Background(), afterClosing)

	// then
	require.Len(t, voteClosed, 1)
	vc := voteClosed[0]
	require.NotNil(t, vc.NewMarket())
	assert.True(t, vc.NewMarket().Rejected())

	// given
	afterEnactment := time.Unix(proposal.Terms.EnactmentTimestamp, 0).Add(time.Second)

	// when
	toBeEnacted, _ := eng.OnTick(context.Background(), afterEnactment)

	// then
	assert.Empty(t, toBeEnacted)
}

func testVotingWithInsufficientParticipationMakesNewMarketProposalDeclined(t *testing.T) {
	eng := getTestEngine(t, time.Now())

	// given
	proposer := vgrand.RandomStr(5)
	proposal := eng.newProposalForNewMarket(proposer, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.ensureStakingAssetTotalSupply(t, 800)
	eng.ensureTokenBalanceForParty(t, proposer, 100)

	// expect
	eng.expectOpenProposalEvent(t, proposer, proposal.ID)

	// when
	_, err := eng.submitProposal(t, proposal)

	// then
	require.NoError(t, err)

	// given
	voter := vgrand.RandomStr(5)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 100)

	// expect
	eng.expectVoteEvent(t, voter, proposal.ID)

	// when
	err = eng.addYesVote(t, voter, proposal.ID)

	// then
	require.NoError(t, err)

	// given
	afterClosing := time.Unix(proposal.Terms.ClosingTimestamp, 0).Add(time.Second)

	// setup
	eng.ensureTokenBalanceForParty(t, voter, 100)

	// expect
	eng.expectDeclinedProposalEvent(t, proposal.ID, types.ProposalErrorParticipationThresholdNotReached)
	eng.expectTotalGovernanceTokenFromVoteEvents(t, "1", "100")
	eng.expectGetMarketState(t, proposal.ID)
	// when
	_, voteClosed := eng.OnTick(context.Background(), afterClosing)

	// then
	require.Len(t, voteClosed, 1)
	vc := voteClosed[0]
	require.NotNil(t, vc.NewMarket())
	assert.True(t, vc.NewMarket().Rejected())

	// given
	afterEnactment := time.Unix(proposal.Terms.EnactmentTimestamp, 0).Add(time.Second)

	// when
	toBeEnacted, _ := eng.OnTick(context.Background(), afterEnactment)

	// then
	assert.Empty(t, toBeEnacted)
}

func testSubmittingProposalForNewPerpsMarketSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	defer eng.ctrl.Finish()

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewPerpsMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)
	require.NoError(t, err)

	// the proposal had a nil initial time for the time trigger.
	// ensure it was set to the enactment time.
	tt := toSubmit.Proposal().Terms.GetNewMarket().Changes.Instrument.
		Product.(*types.InstrumentConfigurationPerps).
		Perps.DataSourceSpecForSettlementSchedule.
		GetInternalTimeTriggerSpecConfiguration().Triggers[0]

	enactmentTime := toSubmit.Proposal().Terms.EnactmentTimestamp

	assert.NotNil(t, tt.Initial)
	assert.Equal(t, tt.Initial.Unix(), enactmentTime)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testSubmittingProposalForNewPerpsMarketWithCustomInitialTimeSucceeds(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	defer eng.ctrl.Finish()

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewPerpsMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	// set the time differently to start e.g sometimes after the enactment ti
	enactAt := proposal.Terms.EnactmentTimestamp
	proposal.Terms.Change.(*types.ProposalTermsNewMarket).NewMarket.Changes.Instrument.Product.(*types.InstrumentConfigurationPerps).Perps.DataSourceSpecForSettlementSchedule.GetInternalTimeTriggerSpecConfiguration().Triggers[0].Initial = ptr.From(time.Unix(enactAt, 0).Add(60 * time.Minute))

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectOpenProposalEvent(t, party.Id, proposal.ID)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)
	require.NoError(t, err)

	// the proposal had a nil initial time for the time trigger.
	// ensure it was set to the enactment time.
	tt := toSubmit.Proposal().Terms.GetNewMarket().Changes.Instrument.
		Product.(*types.InstrumentConfigurationPerps).
		Perps.DataSourceSpecForSettlementSchedule.
		GetInternalTimeTriggerSpecConfiguration().Triggers[0]

	enactmentTime := toSubmit.Proposal().Terms.EnactmentTimestamp

	assert.NotNil(t, tt.Initial)
	assert.NotEqual(t, tt.Initial.Unix(), enactmentTime)

	// then
	require.NoError(t, err)
	require.NotNil(t, toSubmit)
	assert.True(t, toSubmit.IsNewMarket())
	require.NotNil(t, toSubmit.NewMarket().Market())
}

func testSubmittingProposalForNewPerpsMarketWithPastInitialTimeFails(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	defer eng.ctrl.Finish()

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewPerpsMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	now := eng.tsvc.GetTimeNow()
	proposal.Terms.Change.(*types.ProposalTermsNewMarket).NewMarket.Changes.Instrument.Product.(*types.InstrumentConfigurationPerps).Perps.DataSourceSpecForSettlementSchedule.GetInternalTimeTriggerSpecConfiguration().Triggers[0].Initial = ptr.From(now.Add(-(60 * time.Second)))

	// setup
	eng.ensureAllAssetEnabled(t)

	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorInvalidPerpsProduct)

	// when
	toSubmit, err := eng.submitProposal(t, proposal)

	// then
	require.EqualError(t, err, "time trigger starts in the past")
	require.Nil(t, toSubmit)
}

func testInvalidDecimalPlace(t *testing.T) {
	eng := getTestEngine(t, time.Now())
	defer eng.ctrl.Finish()

	// given
	party := eng.newValidParty("a-valid-party", 123456789)
	proposal := eng.newProposalForNewPerpsMarket(party.Id, eng.tsvc.GetTimeNow().Add(2*time.Hour), nil, nil, true)

	proposal.Terms.GetNewMarket().Changes.DecimalPlaces = 12
	proposal.Terms.GetNewMarket().Changes.PositionDecimalPlaces = 7

	// set the time differently to start e.g sometimes after the enactment ti
	enactAt := proposal.Terms.EnactmentTimestamp
	proposal.Terms.Change.(*types.ProposalTermsNewMarket).NewMarket.Changes.Instrument.Product.(*types.InstrumentConfigurationPerps).Perps.DataSourceSpecForSettlementSchedule.GetInternalTimeTriggerSpecConfiguration().Triggers[0].Initial = ptr.From(time.Unix(enactAt, 0).Add(60 * time.Minute))

	// setup
	eng.ensureAllAssetEnabled(t)
	eng.expectRejectedProposalEvent(t, party.Id, proposal.ID, types.ProposalErrorTooManyMarketDecimalPlaces)

	// when
	_, err := eng.submitProposal(t, proposal)
	require.Equal(t, "market decimal + position decimals must be less than or equal to asset decimals", err.Error())
}