runtime

var (

	// ByzantineExecutorHonest is a scenario in which the Byzantine node acts
	// as the primary worker, backup scheduler, and is honest.
	ByzantineExecutorHonest scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/honest",
		"executor",
		nil,
		oasis.ByzantineSlot1IdentitySeed,
		false,
		nil,
		nil,
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
	)
	// ByzantineExecutorSchedulerHonest is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and is honest.
	ByzantineExecutorSchedulerHonest scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/honest",
		"executor",
		nil,
		oasis.ByzantineDefaultIdentitySeed,
		false,
		nil,
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
	)
	// ByzantineExecutorDishonest is a scenario in which the Byzantine node acts
	// as the primary worker, backup scheduler, and is dishonest.
	ByzantineExecutorDishonest scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/dishonest",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertNoTimeouts(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeIncorrectResults: 1,
			staking.SlashRuntimeLiveness:         1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorDishonest.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
	)
	// ByzantineExecutorSchedulerRunaway is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and runs away after publishes a proposal.
	ByzantineExecutorSchedulerRunaway scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/runaway",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertTimeouts(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorRunaway.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
	)
	// ByzantineExecutorSchedulerBogus is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and schedules bogus transactions.
	ByzantineExecutorSchedulerBogus scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/bogus",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertRoundFailures(),
			oasis.LogAssertTimeouts(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineSlot1IdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
			{Name: byzantine.CfgExecutorProposeBogusTx},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
	)
	// ByzantineExecutorStraggler is a scenario in which the Byzantine node acts
	// as the primary worker, backup scheduler, and a straggler.
	ByzantineExecutorStraggler scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/straggler",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertTimeouts(),
			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
	)
	// ByzantineExecutorSchedulerStraggler is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and a straggler.
	ByzantineExecutorSchedulerStraggler scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/straggler",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertTimeouts(),
			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
	)
	// ByzantineExecutorStragglerAllowed is a scenario in which the Byzantine node acts
	// as the primary worker, backup scheduler, and a straggler. One straggler is allowed.
	ByzantineExecutorStragglerAllowed scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/straggler-allowed",
		"executor",
		nil,
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
		withCustomRuntimeConfig(func(rt *oasis.RuntimeFixture) {
			rt.Executor.AllowedStragglers = 1
		}),
	)
	// ByzantineExecutorSchedulerStragglerAllowed is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and a straggler. One straggler is allowed.
	ByzantineExecutorSchedulerStragglerAllowed scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/straggler-allowed",
		"executor",
		nil,
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
		withCustomRuntimeConfig(func(rt *oasis.RuntimeFixture) {

			rt.Executor.AllowedStragglers = 1
		}),
	)
	// ByzantineExecutorBackupStraggler is a scenario in which the Byzantine node acts
	// as the primary and backup worker, backup scheduler, and a straggler.
	ByzantineExecutorBackupStraggler scenario.Scenario = newByzantineImpl(
		"primary-backup-worker/backup-scheduler/straggler",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertTimeouts(),
			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker, scheduler.RoleBackupWorker},
			Index: backupSchedulerIndex,
		},
		withCustomRuntimeConfig(func(rt *oasis.RuntimeFixture) {

			rt.Executor.GroupBackupSize = 3
		}),
	)
	// ByzantineExecutorBackupSchedulerStraggler is a scenario in which the Byzantine node acts
	// as the primary and backup worker, primary scheduler, and a straggler.
	ByzantineExecutorBackupSchedulerStraggler scenario.Scenario = newByzantineImpl(
		"primary-backup-worker/primary-scheduler/straggler",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertTimeouts(),
			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorStraggler.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker, scheduler.RoleBackupWorker},
			Index: primarySchedulerIndex,
		},
		withCustomRuntimeConfig(func(rt *oasis.RuntimeFixture) {

			rt.Executor.GroupBackupSize = 3
		}),
	)
	// ByzantineExecutorFailureIndicating is a scenario in which the Byzantine node acts
	// as the primary worker, backup scheduler, and submits failure indicating commitment.
	ByzantineExecutorFailureIndicating scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/failure-indicating",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertNoTimeouts(),
			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineDefaultIdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorFailureIndicating.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
	)
	// ByzantineExecutorSchedulerFailureIndicating is a scenario in which the Byzantine node acts
	// as the primary worker, primary scheduler, and submits failure indicating commitment.
	ByzantineExecutorSchedulerFailureIndicating scenario.Scenario = newByzantineImpl(
		"primary-worker/primary-scheduler/failure-indicating",
		"executor",
		[]log.WatcherHandlerFactory{

			oasis.LogAssertNoRoundFailures(),
			oasis.LogAssertTimeouts(),
			oasis.LogAssertExecutionDiscrepancyDetected(),
		},
		oasis.ByzantineSlot1IdentitySeed,
		false,

		map[staking.SlashReason]uint64{
			staking.SlashRuntimeLiveness: 1,
		},
		[]oasis.Argument{
			{Name: byzantine.CfgPrimarySchedulerExpected},
			{Name: byzantine.CfgExecutorMode, Values: []string{byzantine.ModeExecutorFailureIndicating.String()}},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: primarySchedulerIndex,
		},
	)
	// ByzantineExecutorCorruptGetDiff is the byzantine executor node scenario that corrupts GetDiff
	// responses.
	ByzantineExecutorCorruptGetDiff scenario.Scenario = newByzantineImpl(
		"primary-worker/backup-scheduler/corrupt-getdiff",
		"executor",

		nil,
		oasis.ByzantineDefaultIdentitySeed,
		false,
		nil,
		[]oasis.Argument{

			{Name: byzantine.CfgCorruptGetDiff},
		},
		scheduler.ForceElectCommitteeRole{
			Kind:  scheduler.KindComputeExecutor,
			Roles: []scheduler.Role{scheduler.RoleWorker},
			Index: backupSchedulerIndex,
		},
	)
)

var (
	// DumpRestore is the dump and restore scenario.
	DumpRestore scenario.Scenario = newDumpRestoreImpl("dump-restore", nil)

	// DumpRestoreRuntimeRoundAdvance is the scenario where additional rounds are simulated after
	// the runtime stopped in the old network (so storage node state is behind).
	DumpRestoreRuntimeRoundAdvance scenario.Scenario = newDumpRestoreImpl(
		"dump-restore/runtime-round-advance",
		func(doc *genesis.Document) {

			for _, st := range doc.RootHash.RuntimeStates {
				st.Round += 10
			}
		},
	)
)

var (
	// EarlyQuery is the early query scenario where we query a validator node before the network
	// has started and there are no committed blocks.
	EarlyQuery scenario.Scenario = &earlyQueryImpl{
		Scenario: e2e.NewScenario("early-query"),
	}

	// EarlyQueryInitHeight is the same as EarlyQuery scenario but with an initial height set.
	EarlyQueryInitHeight scenario.Scenario = &earlyQueryImpl{
		Scenario:      e2e.NewScenario("early-query/init-height"),
		initialHeight: 42,
	}

	// EarlyQueryRuntime is the early query scenario where we query a runtime node.
	EarlyQueryRuntime scenario.Scenario = &earlyQueryImpl{
		Scenario: NewScenario("early-query", nil),
		runtime:  true,
	}
)

var (
	// GovernanceConsensusUpgrade is the governance consensus upgrade scenario.
	GovernanceConsensusUpgrade scenario.Scenario = newGovernanceConsensusUpgradeImpl(true, false)
	// GovernanceConsensusFailUpgrade is the governance consensus upgrade scenario
	// where node should fail the upgrade.
	GovernanceConsensusFailUpgrade scenario.Scenario = newGovernanceConsensusUpgradeImpl(false, false)
	// GovernanceConsensusCancelUpgrade is the governance consensus upgrade scenario
	// where the pending upgrade is canceled.
	GovernanceConsensusCancelUpgrade scenario.Scenario = newGovernanceConsensusUpgradeImpl(true, true)
)

var (
	// HaltRestore is the halt and restore scenario.
	HaltRestore scenario.Scenario = newHaltRestoreImpl(false)
	// HaltRestoreSuspended is the halt and restore scenario with a suspended runtime.
	HaltRestoreSuspended scenario.Scenario = newHaltRestoreImpl(true)
)

var (
	// KeyValueRuntimeBinary is the name of the simple key/value runtime binary.
	KeyValueRuntimeBinary = "simple-keyvalue"
	// KeyValueRuntimeUpgradeBinary is the name of the upgraded simple key/value runtime binary.
	KeyValueRuntimeUpgradeBinary = "simple-keyvalue-upgrade"
	// KeyManagerRuntimeBinary is the name of the simple key manager runtime binary.
	KeyManagerRuntimeBinary = "simple-keymanager"
	// KeyManagerRuntimeUpgradeBinary is the name of the upgraded simple key manager runtime binary.
	KeyManagerRuntimeUpgradeBinary = "simple-keymanager-upgrade"

	// KeyValueRuntimeID is the ID of the simple key/value runtime.
	KeyValueRuntimeID common.Namespace
	// KeyManagerRuntimeID is the ID of the key manager runtime.
	KeyManagerRuntimeID common.Namespace
)

var (
	// ParamsDummyScenario is a dummy instance of runtimeImpl used to register global e2e/runtime flags.
	ParamsDummyScenario = NewScenario("", nil)

	// Runtime is the basic network + client test case with runtime support.
	Runtime scenario.Scenario = NewScenario(
		"runtime",
		NewTestClient().WithScenario(SimpleKeyValueScenario),
	)

	// RuntimeEncryption is the basic network + client with encryption test case.
	RuntimeEncryption scenario.Scenario = NewScenario(
		"runtime-encryption",
		NewTestClient().WithScenario(InsertRemoveKeyValueEncScenario),
	)

	// DefaultRuntimeLogWatcherHandlerFactories is a list of default log watcher
	// handler factories for the basic scenario.
	DefaultRuntimeLogWatcherHandlerFactories = []log.WatcherHandlerFactory{
		oasis.LogAssertNoTimeouts(),
		oasis.LogAssertNoRoundFailures(),
		oasis.LogAssertNoExecutionDiscrepancyDetected(),
	}
)

var (
	InsertKeyValueScenario = NewTestClientScenario([]interface{}{
		InsertKeyValueTx{"my_key", "my_value", "", false, 0},
		GetKeyValueTx{"my_key", "my_value", false, 0},
	})

	InsertKeyValueEncScenario = NewTestClientScenario([]interface{}{
		InsertKeyValueTx{"my_key", "my_value", "", true, 0},
		GetKeyValueTx{"my_key", "my_value", true, 0},
	})

	RemoveKeyValueScenario = NewTestClientScenario([]interface{}{
		GetKeyValueTx{"my_key", "my_value", false, 0},
	})

	RemoveKeyValueEncScenario = NewTestClientScenario([]interface{}{
		GetKeyValueTx{"my_key", "my_value", true, 0},
	})

	InsertTransferKeyValueScenario = NewTestClientScenario([]interface{}{
		InsertKeyValueTx{"my_key", "my_value", "", false, 0},
		GetKeyValueTx{"my_key", "my_value", false, 0},
		ConsensusTransferTx{},
	})

	InsertRemoveKeyValueEncScenario = NewTestClientScenario([]interface{}{
		InsertKeyValueTx{"my_key", "my_value", "", true, 0},
		GetKeyValueTx{"my_key", "my_value", true, 0},
		RemoveKeyValueTx{"my_key", "my_value", true, 0},
		GetKeyValueTx{"my_key", "", true, 0},
	})

	InsertRemoveKeyValueEncScenarioV2 = NewTestClientScenario([]interface{}{
		InsertKeyValueTx{"my_key2", "my_value2", "", true, 0},
		GetKeyValueTx{"my_key2", "my_value2", true, 0},
		RemoveKeyValueTx{"my_key2", "my_value2", true, 0},
		GetKeyValueTx{"my_key2", "", true, 0},
	})

	SimpleKeyValueScenario = newSimpleKeyValueScenario(false, false)

	SimpleKeyValueEncScenario = newSimpleKeyValueScenario(false, true)

	SimpleKeyValueScenarioRepeated = newSimpleKeyValueScenario(true, false)
)

var (
	// TrustRootChangeTest is a happy path scenario which tests if trust
	// can be transferred to a new light block when consensus chain context
	// changes, e.g. on dump-restore network upgrades.
	TrustRootChangeTest scenario.Scenario = newTrustRootChangeImpl(
		"change",
		NewTestClient().WithScenario(InsertKeyValueEncScenario),
		true,
	)

	// TrustRootChangeFailsTest is an unhappy path scenario which tests
	// that trust is never transferred to untrusted or invalid light blocks when
	// consensus chain context changes.
	TrustRootChangeFailsTest scenario.Scenario = newTrustRootChangeImpl(
		"change-fails",
		NewTestClient().WithScenario(SimpleKeyValueEncScenario),
		false,
	)
)

var ArchiveAPI scenario.Scenario = &archiveAPI{
	Scenario: *NewScenario(
		"archive-api",
		NewTestClient().WithScenario(InsertTransferKeyValueScenario),
	),
}

var GasFeesRuntimes scenario.Scenario = &gasFeesRuntimesImpl{
	Scenario: *NewScenario("gas-fees/runtimes", nil),
}

var HaltRestoreNonMock scenario.Scenario = newHaltRestoreNonMockImpl()

var HistoryReindex scenario.Scenario = newHistoryReindexImpl()

var KeymanagerDumpRestore scenario.Scenario = newKmDumpRestoreImpl()

var KeymanagerEphemeralSecrets scenario.Scenario = newKmEphemeralSecretsImpl()

var KeymanagerMasterSecrets scenario.Scenario = newKmMasterSecretsImpl()

var KeymanagerReplicate scenario.Scenario = newKmReplicateImpl()

var KeymanagerReplicateMany scenario.Scenario = newKmReplicateManyImpl()

var KeymanagerRestart scenario.Scenario = newKmRestartImpl()

var KeymanagerRotationFailure scenario.Scenario = newKmRotationFailureImpl()

var KeymanagerUpgrade scenario.Scenario = NewKmUpgradeImpl()

var LateStart scenario.Scenario = newLateStartImpl("late-start")

var MultipleRuntimes = func() scenario.Scenario {
	sc := &multipleRuntimesImpl{
		Scenario: *NewScenario("multiple-runtimes", nil),
	}
	sc.Flags.Int(cfgNumComputeRuntimes, 2, "number of compute runtimes per worker")
	sc.Flags.Int(cfgNumComputeRuntimeTxns, 2, "number of transactions to perform")
	sc.Flags.Int(cfgNumComputeWorkers, 2, "number of workers to initiate")
	sc.Flags.Uint16(cfgExecutorGroupSize, 2, "number of executor workers in committee")

	return sc
}()

var NodeShutdown scenario.Scenario = newNodeShutdownImpl()

var OffsetRestart scenario.Scenario = newOffsetRestartImpl()

var RuntimeDynamic scenario.Scenario = newRuntimeDynamicImpl()

var RuntimeGovernance = func() scenario.Scenario {
	sc := &runtimeGovernanceImpl{
		Scenario: *NewScenario("runtime-governance", nil),
	}
	return sc
}()

var RuntimeMessage scenario.Scenario = newRuntimeMessage()

var RuntimePrune scenario.Scenario = newRuntimePruneImpl()

var RuntimeUpgrade scenario.Scenario = newRuntimeUpgradeImpl()

var (
	// Sentry is the Sentry node basic scenario.
	Sentry scenario.Scenario = newSentryImpl()
)

var StorageEarlyStateSync scenario.Scenario = newStorageEarlyStateSyncImpl()

var StorageSync scenario.Scenario = newStorageSyncImpl()

var StorageSyncFromRegistered scenario.Scenario = newStorageSyncFromRegisteredImpl()

var StorageSyncInconsistent scenario.Scenario = newStorageSyncInconsistentImpl()

var TrustRoot scenario.Scenario = NewTrustRootImpl(
	"simple",
	NewTestClient().WithScenario(SimpleKeyValueEncScenario),
)

var TxSourceMulti scenario.Scenario = &txSourceImpl{
	Scenario: *NewScenario("txsource-multi", nil),
	clientWorkloads: []string{
		workload.NameCommission,
		workload.NameDelegation,
		workload.NameOversized,
		workload.NameParallel,
		workload.NameRegistration,
		workload.NameRuntime,
		workload.NameTransfer,
		workload.NameGovernance,
	},
	allNodeWorkloads: []string{
		workload.NameQueries,
	},
	timeLimit:                         timeLimitLong,
	nodeRestartInterval:               nodeRestartIntervalLong,
	nodeLongRestartInterval:           nodeLongRestartInterval,
	nodeLongRestartDuration:           nodeLongRestartDuration,
	livenessCheckInterval:             livenessCheckInterval,
	consensusPruneDisabledProbability: 0.1,
	consensusPruneMinKept:             100,
	consensusPruneMaxKept:             1000,
	enableCrashPoints:                 true,

	cmtRecoverCorruptedWAL: true,

	numValidatorNodes: 4,

	numKeyManagerNodes: 2,

	numComputeNodes: 5,

	numClientNodes: 2,
}

var TxSourceMultiShort scenario.Scenario = &txSourceImpl{
	Scenario: *NewScenario("txsource-multi-short", nil),
	clientWorkloads: []string{
		workload.NameCommission,
		workload.NameDelegation,
		workload.NameOversized,
		workload.NameParallel,
		workload.NameRegistration,
		workload.NameRuntime,
		workload.NameTransfer,
		workload.NameGovernance,
	},
	allNodeWorkloads: []string{
		workload.NameQueries,
	},
	timeLimit:                         timeLimitShort,
	livenessCheckInterval:             livenessCheckInterval,
	consensusPruneDisabledProbability: 0.1,
	consensusPruneMinKept:             100,
	consensusPruneMaxKept:             200,
	numValidatorNodes:                 4,
	numKeyManagerNodes:                2,
	numComputeNodes:                   4,
	numClientNodes:                    2,
}

var TxSourceMultiShortSGX scenario.Scenario = &txSourceImpl{
	Scenario: *NewScenario("txsource-multi-short-sgx", nil),
	clientWorkloads: []string{
		workload.NameCommission,
		workload.NameDelegation,
		workload.NameOversized,
		workload.NameParallel,
		workload.NameRegistration,
		workload.NameRuntime,
		workload.NameTransfer,
		workload.NameGovernance,
	},
	allNodeWorkloads: []string{
		workload.NameQueries,
	},
	timeLimit:                         timeLimitShortSGX,
	livenessCheckInterval:             livenessCheckInterval,
	consensusPruneDisabledProbability: 0.1,
	consensusPruneMinKept:             100,
	consensusPruneMaxKept:             200,

	numValidatorNodes:  2,
	numKeyManagerNodes: 1,
	numComputeNodes:    2,
	numClientNodes:     1,
}