tangle.go

package tangle

import (
	"container/list"
	"time"

	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/approvers"
	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/missingtransaction"
	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/valuetransfer"
	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
	"github.com/iotaledger/goshimmer/packages/storageprefix"

	"github.com/iotaledger/hive.go/async"
	"github.com/iotaledger/hive.go/objectstorage"
)

const (
	MAX_MISSING_TIME_BEFORE_CLEANUP = 30 * time.Second
	MISSING_CHECK_INTERVAL          = 5 * time.Second
)

type Tangle struct {
	storageId []byte

	transactionStorage         *objectstorage.ObjectStorage
	transactionMetadataStorage *objectstorage.ObjectStorage
	approversStorage           *objectstorage.ObjectStorage
	missingTransactionsStorage *objectstorage.ObjectStorage

	Events Events

	storeTransactionsWorkerPool async.WorkerPool
	solidifierWorkerPool        async.WorkerPool
	cleanupWorkerPool           async.WorkerPool
}

// Constructor for the tangle.
func New(storageId []byte) (result *Tangle) {
	result = &Tangle{
		storageId:                  storageId,
		transactionStorage:         objectstorage.New(append(storageId, storageprefix.TangleTransaction...), transaction.FromStorage),
		transactionMetadataStorage: objectstorage.New(append(storageId, storageprefix.TangleTransactionMetadata...), transactionmetadata.FromStorage),
		approversStorage:           objectstorage.New(append(storageId, storageprefix.TangleApprovers...), approvers.FromStorage),
		missingTransactionsStorage: objectstorage.New(append(storageId, storageprefix.TangleMissingTransaction...), missingtransaction.FromStorage),

		Events: *newEvents(),
	}

	result.solidifierWorkerPool.Tune(1024)

	return
}

func (tangle *Tangle) LoadSnapshot(snapshot *Snapshot) {
	fakeTransactionId := func(tx *transaction.Transaction, id transaction.Id) *transaction.Transaction {
		fakedTransaction := transaction.FromStorage(id[:])
		if err := fakedTransaction.UnmarshalBinary(tx.GetBytes()); err != nil {
			panic(err)
		}

		return fakedTransaction.(*transaction.Transaction)
	}

	for transactionId, addresses := range snapshot.SolidEntryPoints {
		if addresses == nil {
			tangle.AttachTransaction(fakeTransactionId(transaction.New(transaction.EmptyId, transaction.EmptyId, nil, data.New(nil)), transactionId))
		} else {
			valueTransfer := valuetransfer.New()