Moved the mempool provider into the ledger provider

packages/app/blockissuer/blockfactory/referenceprovider.go

@@ -121,15 +121,15 @@ func (r *ReferenceProvider) referencesFromUnacceptedInputs(payload payload.Paylo
 		return weakParents, likeInsteadParents, nil
 	}
 
-	referencedTransactions := engineInstance.Ledger.Utils().ReferencedTransactions(tx)
+	referencedTransactions := engineInstance.Ledger.MemPool().Utils().ReferencedTransactions(tx)
 	for it := referencedTransactions.Iterator(); it.HasNext(); {
 		referencedTransactionID := it.Next()
 
 		if len(weakParents) == models.MaxParentsCount {
 			return weakParents, likeInsteadParents, nil
 		}
 
-		if !engineInstance.Ledger.Utils().TransactionConfirmationState(referencedTransactionID).IsAccepted() {
+		if !engineInstance.Ledger.MemPool().Utils().TransactionConfirmationState(referencedTransactionID).IsAccepted() {
 			latestAttachment := engineInstance.Tangle.Booker.GetLatestAttachment(referencedTransactionID)
 			if latestAttachment == nil {
 				continue
@@ -264,7 +264,7 @@ func (r *ReferenceProvider) adjustOpinion(conflictID utxo.TransactionID, exclude
 		return false, models.EmptyBlockID, err
 	}
 
-	excludedConflictIDs.AddAll(engineInstance.Ledger.Utils().ConflictIDsInFutureCone(dislikedConflictIDs))
+	excludedConflictIDs.AddAll(engineInstance.Ledger.MemPool().Utils().ConflictIDsInFutureCone(dislikedConflictIDs))
 
 	return true, attachment.ID(), nil
 }
@@ -298,7 +298,7 @@ func (r *ReferenceProvider) payloadLiked(blockID models.BlockID) (liked bool) {
 	conflictIDs := engineInstance.Tangle.Booker.TransactionConflictIDs(block)
 
 	for it := conflictIDs.Iterator(); it.HasNext(); {
-		conflict, exists := engineInstance.Ledger.ConflictDAG().Conflict(it.Next())
+		conflict, exists := engineInstance.Ledger.MemPool().ConflictDAG().Conflict(it.Next())
 		if !exists {
 			continue
 		}

packages/core/snapshotcreator/options.go

@@ -6,7 +6,7 @@ import (
 	"github.com/iotaledger/goshimmer/packages/core/database"
 	"github.com/iotaledger/goshimmer/packages/core/module"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine"
-	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger"
 	"github.com/iotaledger/hive.go/crypto/ed25519"
 	"github.com/iotaledger/hive.go/runtime/options"
 
@@ -41,7 +41,7 @@ type Options struct {
 
 	DataBaseVersion database.Version
 
-	LedgerProvider module.Provider[*engine.Engine, mempool.MemPool]
+	LedgerProvider module.Provider[*engine.Engine, ledger.Ledger]
 }
 
 func NewOptions(opts ...options.Option[Options]) *Options {
@@ -174,7 +174,7 @@ func WithDatabaseVersion(databaseVersion database.Version) options.Option[Option
 }
 
 // WithLedgerProvider sets the MemPool to use for the snapshot.
-func WithLedgerProvider(ledgerProvider module.Provider[*engine.Engine, mempool.MemPool]) options.Option[Options] {
+func WithLedgerProvider(ledgerProvider module.Provider[*engine.Engine, ledger.Ledger]) options.Option[Options] {
 	return func(m *Options) {
 		m.LedgerProvider = ledgerProvider
 	}

packages/core/snapshotcreator/snapshotcreator.go

@@ -13,7 +13,6 @@ import (
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/clock/blocktime"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxo"
-	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxoledger"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/devnetvm"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/mockedvm"
@@ -64,7 +63,6 @@ func CreateSnapshot(opts ...options.Option[Options]) error {
 		s,
 		blocktime.NewProvider(),
 		opt.LedgerProvider,
-		utxoledger.NewProvider(),
 		dpos.NewProvider(),
 		mana1.NewProvider(),
 	)
@@ -84,11 +82,11 @@ func CreateSnapshot(opts ...options.Option[Options]) error {
 	nodesToPledge.ForEach(func(nodeIdentity *identity.Identity, value uint64) bool {
 		nodePublicKey := nodeIdentity.PublicKey()
 		nodeID := nodeIdentity.ID()
-		output, outputMetadata, errOut := createOutput(engineInstance.Ledger.VM(), nodePublicKey, value, nodeID, 0)
+		output, outputMetadata, errOut := createOutput(engineInstance.Ledger.MemPool().VM(), nodePublicKey, value, nodeID, 0)
 		if errOut != nil {
 			panic(errOut)
 		}
-		if err = engineInstance.LedgerState.UnspentOutputs().ApplyCreatedOutput(mempool.NewOutputWithMetadata(0, output.ID(), output, outputMetadata.ConsensusManaPledgeID(), outputMetadata.AccessManaPledgeID())); err != nil {
+		if err = engineInstance.Ledger.UnspentOutputs().ApplyCreatedOutput(mempool.NewOutputWithMetadata(0, output.ID(), output, outputMetadata.ConsensusManaPledgeID(), outputMetadata.AccessManaPledgeID())); err != nil {
 			panic(err)
 		}
 
@@ -138,11 +136,11 @@ func (m *Options) createAttestationIfNotYetDone(engineInstance *engine.Engine) (
 
 func (m *Options) createGenesisOutput(engineInstance *engine.Engine) error {
 	if m.GenesisTokenAmount > 0 {
-		output, outputMetadata, err := createOutput(engineInstance.Ledger.VM(), seed.NewSeed(m.GenesisSeed).KeyPair(0).PublicKey, m.GenesisTokenAmount, identity.ID{}, 0)
+		output, outputMetadata, err := createOutput(engineInstance.Ledger.MemPool().VM(), seed.NewSeed(m.GenesisSeed).KeyPair(0).PublicKey, m.GenesisTokenAmount, identity.ID{}, 0)
 		if err != nil {
 			return err
 		}
-		if err := engineInstance.LedgerState.UnspentOutputs().ApplyCreatedOutput(mempool.NewOutputWithMetadata(0, output.ID(), output, outputMetadata.ConsensusManaPledgeID(), outputMetadata.AccessManaPledgeID())); err != nil {
+		if err := engineInstance.Ledger.UnspentOutputs().ApplyCreatedOutput(mempool.NewOutputWithMetadata(0, output.ID(), output, outputMetadata.ConsensusManaPledgeID(), outputMetadata.AccessManaPledgeID())); err != nil {
 			return err
 		}
 	}

packages/protocol/congestioncontrol/icca/scheduler/testframework.go

@@ -15,6 +15,7 @@ import (
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/eviction"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/realitiesledger"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxoledger"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/mockedvm"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/sybilprotection/dpos"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/tangle"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/tangle/blockdag"
@@ -64,7 +65,12 @@ func NewTestFramework(test *testing.T, workers *workerpool.Group, optsScheduler
 	}
 	t.storage = storage.New(test.TempDir(), 1)
 
-	ledgerProvider := realitiesledger.NewProvider()
+	ledgerProvider := utxoledger.NewProvider(
+		utxoledger.WithMemPoolProvider(
+			realitiesledger.NewProvider(
+				realitiesledger.WithVM(new(mockedvm.MockedVM))),
+		),
+	)
 
 	tempDir := utils.NewDirectory(test.TempDir())
 	require.NoError(test, snapshotcreator.CreateSnapshot(snapshotcreator.WithDatabaseVersion(1),
@@ -79,7 +85,6 @@ func NewTestFramework(test *testing.T, workers *workerpool.Group, optsScheduler
 		t.storage,
 		blocktime.NewProvider(),
 		ledgerProvider,
-		utxoledger.NewProvider(),
 		dpos.NewProvider(),
 		mana1.NewProvider(),
 	)

packages/protocol/engine/clock/blocktime/clock.go

@@ -31,7 +31,7 @@ func NewProvider(opts ...options.Option[Clock]) module.Provider[*engine.Engine,
 			confirmedTime: NewRelativeTime(),
 		}, opts, func(c *Clock) {
 			e.HookConstructed(func() {
-				e.LedgerState.HookInitialized(func() {
+				e.Ledger.HookInitialized(func() {
 					c.acceptedTime.Set(e.SlotTimeProvider().EndTime(e.Storage.Settings.LatestCommitment().Index()))
 					c.confirmedTime.Set(e.SlotTimeProvider().EndTime(e.Storage.Settings.LatestCommitment().Index()))
 

packages/protocol/engine/engine.go

@@ -42,8 +42,7 @@ type Engine struct {
 	Storage             *storage.Storage
 	SybilProtection     sybilprotection.SybilProtection
 	ThroughputQuota     throughputquota.ThroughputQuota
-	Ledger              mempool.MemPool
-	LedgerState         ledger.Ledger
+	Ledger              ledger.Ledger
 	Filter              *filter.Filter
 	EvictionState       *eviction.State
 	BlockRequester      *eventticker.EventTicker[models.BlockID]
@@ -75,8 +74,7 @@ func New(
 	workers *workerpool.Group,
 	storageInstance *storage.Storage,
 	clockProvider module.Provider[*Engine, clock.Clock],
-	ledger module.Provider[*Engine, mempool.MemPool],
-	ledgerState module.Provider[*Engine, ledger.Ledger],
+	ledger module.Provider[*Engine, ledger.Ledger],
 	sybilProtection module.Provider[*Engine, sybilprotection.SybilProtection],
 	throughputQuota module.Provider[*Engine, throughputquota.ThroughputQuota],
 	opts ...options.Option[Engine],
@@ -92,12 +90,11 @@ func New(
 			optsSnapshotDepth:         5,
 		}, opts, func(e *Engine) {
 			e.Ledger = ledger(e)
-			e.LedgerState = ledgerState(e)
 			e.Clock = clockProvider(e)
 			e.SybilProtection = sybilProtection(e)
 			e.ThroughputQuota = throughputQuota(e)
-			e.NotarizationManager = notarization.NewManager(e.Storage, e.LedgerState, e.SybilProtection.Weights(), e.optsNotarizationManagerOptions...)
-			e.Tangle = tangle.New(e.Workers.CreateGroup("Tangle"), e.Ledger, e.EvictionState, e.SlotTimeProvider, e.SybilProtection.Validators(), e.LastConfirmedSlot, e.FirstUnacceptedMarker, e.Storage.Commitments.Load, e.optsTangleOptions...)
+			e.NotarizationManager = notarization.NewManager(e.Storage, e.Ledger, e.SybilProtection.Weights(), e.optsNotarizationManagerOptions...)
+			e.Tangle = tangle.New(e.Workers.CreateGroup("Tangle"), e.Ledger.MemPool(), e.EvictionState, e.SlotTimeProvider, e.SybilProtection.Validators(), e.LastConfirmedSlot, e.FirstUnacceptedMarker, e.Storage.Commitments.Load, e.optsTangleOptions...)
 			e.Consensus = consensus.New(e.Workers.CreateGroup("Consensus"), e.Tangle, e.EvictionState, e.Storage.Permanent.Settings.LatestConfirmedSlot(), func() (totalWeight int64) {
 				if zeroIdentityWeight, exists := e.SybilProtection.Weights().Get(identity.ID{}); exists {
 					totalWeight -= zeroIdentityWeight.Value
@@ -112,7 +109,6 @@ func New(
 			e.HookInitialized(lo.Batch(
 				e.Storage.Settings.TriggerInitialized,
 				e.Storage.Commitments.TriggerInitialized,
-				e.LedgerState.TriggerInitialized,
 				e.NotarizationManager.TriggerInitialized,
 				func() {
 					// TODO: hack until consensus is made an engine module
@@ -137,7 +133,6 @@ func (e *Engine) Shutdown() {
 		e.TriggerStopped()
 
 		e.BlockRequester.Shutdown()
-		e.Ledger.Shutdown()
 		e.Workers.Shutdown()
 		e.Storage.Shutdown()
 	}
@@ -239,8 +234,8 @@ func (e *Engine) Import(reader io.ReadSeeker) (err error) {
 		return errors.Wrap(err, "failed to import commitments")
 	} else if err = e.Storage.Settings.SetChainID(e.Storage.Settings.LatestCommitment().ID()); err != nil {
 		return errors.Wrap(err, "failed to set chainID")
-	} else if err = e.LedgerState.Import(reader); err != nil {
-		return errors.Wrap(err, "failed to import ledger state")
+	} else if err = e.Ledger.Import(reader); err != nil {
+		return errors.Wrap(err, "failed to import ledger")
 	} else if err = e.EvictionState.Import(reader); err != nil {
 		return errors.Wrap(err, "failed to import eviction state")
 	} else if err = e.NotarizationManager.Import(reader); err != nil {
@@ -255,8 +250,8 @@ func (e *Engine) Export(writer io.WriteSeeker, targetSlot slot.Index) (err error
 		return errors.Wrap(err, "failed to export settings")
 	} else if err = e.Storage.Commitments.Export(writer, targetSlot); err != nil {
 		return errors.Wrap(err, "failed to export commitments")
-	} else if err = e.LedgerState.Export(writer, targetSlot); err != nil {
-		return errors.Wrap(err, "failed to export ledger state")
+	} else if err = e.Ledger.Export(writer, targetSlot); err != nil {
+		return errors.Wrap(err, "failed to export ledger")
 	} else if err = e.EvictionState.Export(writer, targetSlot); err != nil {
 		return errors.Wrap(err, "failed to export eviction state")
 	} else if err = e.NotarizationManager.Export(writer, targetSlot); err != nil {
@@ -345,12 +340,12 @@ func (e *Engine) setupNotarizationManager() {
 	wpCommitments := e.Workers.CreatePool("NotarizationManager.Commitments", 1) // Using just 1 worker to avoid contention
 
 	// SlotMutations must be hooked because inclusion might be added before transaction are added.
-	e.Events.Ledger.TransactionAccepted.Hook(func(event *mempool.TransactionEvent) {
+	e.Events.MemPool.TransactionAccepted.Hook(func(event *mempool.TransactionEvent) {
 		if err := e.NotarizationManager.SlotMutations.AddAcceptedTransaction(event.Metadata); err != nil {
 			e.Events.Error.Trigger(errors.Wrapf(err, "failed to add accepted transaction %s to slot", event.Metadata.ID()))
 		}
 	})
-	e.Events.Ledger.TransactionInclusionUpdated.Hook(func(event *mempool.TransactionInclusionUpdatedEvent) {
+	e.Events.MemPool.TransactionInclusionUpdated.Hook(func(event *mempool.TransactionInclusionUpdatedEvent) {
 		if err := e.NotarizationManager.SlotMutations.UpdateTransactionInclusion(event.TransactionID, event.PreviousInclusionSlot, event.InclusionSlot); err != nil {
 			e.Events.Error.Trigger(errors.Wrapf(err, "failed to update transaction inclusion time %s in slot", event.TransactionID))
 		}
@@ -372,7 +367,7 @@ func (e *Engine) setupNotarizationManager() {
 }
 
 func (e *Engine) setupEvictionState() {
-	e.LedgerState.HookInitialized(func() {
+	e.Ledger.HookInitialized(func() {
 		e.EvictionState.EvictUntil(e.Storage.Settings.LatestCommitment().Index())
 	})
 

packages/protocol/engine/events.go

@@ -19,7 +19,7 @@ type Events struct {
 
 	EvictionState       *eviction.Events
 	Filter              *filter.Events
-	Ledger              *mempool.Events
+	MemPool             *mempool.Events
 	Tangle              *tangle.Events
 	Consensus           *consensus.Events
 	Clock               *clock.Events
@@ -37,7 +37,7 @@ var NewEvents = event.CreateGroupConstructor(func() (newEvents *Events) {
 		BlockProcessed:      event.New1[models.BlockID](),
 		EvictionState:       eviction.NewEvents(),
 		Filter:              filter.NewEvents(),
-		Ledger:              mempool.NewEvents(),
+		MemPool:             mempool.NewEvents(),
 		Tangle:              tangle.NewEvents(),
 		Consensus:           consensus.NewEvents(),
 		Clock:               clock.NewEvents(),

packages/protocol/engine/ledger/mempool/realitiesledger/ledger.go

@@ -12,7 +12,7 @@ import (
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/conflictdag"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxo"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm"
-	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/mockedvm"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/devnetvm"
 	"github.com/iotaledger/goshimmer/packages/storage"
 	"github.com/iotaledger/hive.go/core/slot"
 	"github.com/iotaledger/hive.go/ds/walker"
@@ -91,8 +91,8 @@ func NewProvider(opts ...options.Option[RealitiesLedger]) module.Provider[*engin
 		l := New(opts...)
 
 		e.HookConstructed(func() {
-			l.Initialize(e.Workers.CreatePool("RealitiesLedger", 2), e.Storage)
-			e.Events.Ledger.LinkTo(l.events)
+			l.Initialize(e.Workers.CreatePool("MemPool", 2), e.Storage)
+			e.Events.MemPool.LinkTo(l.events)
 		})
 
 		return l
@@ -103,7 +103,7 @@ func New(opts ...options.Option[RealitiesLedger]) *RealitiesLedger {
 	return options.Apply(&RealitiesLedger{
 		events:                          mempool.NewEvents(),
 		optsCacheTimeProvider:           database.NewCacheTimeProvider(0),
-		optsVM:                          mockedvm.NewMockedVM(),
+		optsVM:                          new(devnetvm.VM),
 		optsTransactionCacheTime:        10 * time.Second,
 		optTransactionMetadataCacheTime: 10 * time.Second,
 		optsOutputCacheTime:             10 * time.Second,
@@ -127,17 +127,19 @@ func (l *RealitiesLedger) Initialize(workerPool *workerpool.WorkerPool, storage
 
 	l.storage = newStorage(l, l.chainStorage.UnspentOutputs)
 
+	asyncOpt := event.WithWorkerPool(l.workerPool)
+
 	// TODO: revisit whether we should make the process of setting conflict and transaction as accepted/rejected atomic
 	l.conflictDAG.Events.ConflictAccepted.Hook(func(conflict *conflictdag.Conflict[utxo.TransactionID, utxo.OutputID]) {
 		l.propagateAcceptanceToIncludedTransactions(conflict.ID())
-	}, event.WithWorkerPool(l.workerPool))
-	l.conflictDAG.Events.ConflictRejected.Hook(l.propagatedRejectionToTransactions, event.WithWorkerPool(l.workerPool))
+	}, asyncOpt)
+	l.conflictDAG.Events.ConflictRejected.Hook(l.propagatedRejectionToTransactions, asyncOpt)
 	l.events.TransactionBooked.Hook(func(event *mempool.TransactionBookedEvent) {
 		l.processConsumingTransactions(event.Outputs.IDs())
-	}, event.WithWorkerPool(l.workerPool))
+	}, asyncOpt)
 	l.events.TransactionInvalid.Hook(func(event *mempool.TransactionInvalidEvent) {
 		l.PruneTransaction(event.TransactionID, true)
-	}, event.WithWorkerPool(l.workerPool))
+	}, asyncOpt)
 
 	l.TriggerInitialized()
 }
@@ -212,8 +214,11 @@ func (l *RealitiesLedger) PruneTransaction(txID utxo.TransactionID, pruneFutureC
 
 // Shutdown shuts down the stateful elements of the RealitiesLedger (the Storage and the conflictDAG).
 func (l *RealitiesLedger) Shutdown() {
+	l.workerPool.Shutdown()
 	l.workerPool.PendingTasksCounter.WaitIsZero()
 	l.storage.Shutdown()
+
+	l.TriggerStopped()
 }
 
 // processTransaction tries to book a single Transaction.

packages/protocol/engine/ledger/mempool/realitiesledger/test.go

@@ -4,14 +4,17 @@ import (
 	"testing"
 
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/mockedvm"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/tangle/blockdag"
 	"github.com/iotaledger/hive.go/runtime/options"
 	"github.com/iotaledger/hive.go/runtime/workerpool"
 )
 
 func NewTestLedger(t *testing.T, workers *workerpool.Group, optsLedger ...options.Option[RealitiesLedger]) mempool.MemPool {
 	storage := blockdag.NewTestStorage(t, workers)
-	l := New(optsLedger...)
+	l := New(append([]options.Option[RealitiesLedger]{
+		WithVM(new(mockedvm.MockedVM)),
+	}, optsLedger...)...)
 	l.Initialize(workers.CreatePool("RealitiesLedger", 2), storage)
 
 	t.Cleanup(func() {