mempool

type CommitmentInputState struct {
	Commitment *iotago.Commitment
}

type CommitmentInputStateRef struct {
	Input *iotago.CommitmentInput
}

type MemPool[VoteRank spenddag.VoteRankType[VoteRank]] interface {
	AttachSignedTransaction(signedTransaction SignedTransaction, transaction Transaction, blockID iotago.BlockID) (signedTransactionMetadata SignedTransactionMetadata, err error)

	OnAttachTransactionFailed(callback func(transactionID iotago.TransactionID, blockID iotago.BlockID, err error), opts ...event.Option) *event.Hook[func(transactionID iotago.TransactionID, blockID iotago.BlockID, err error)]

	OnSignedTransactionAttached(callback func(signedTransactionMetadata SignedTransactionMetadata), opts ...event.Option) *event.Hook[func(metadata SignedTransactionMetadata)]

	OnTransactionAttached(callback func(metadata TransactionMetadata), opts ...event.Option) *event.Hook[func(metadata TransactionMetadata)]

	MarkAttachmentIncluded(blockID iotago.BlockID) bool

	StateMetadata(reference StateReference) (state StateMetadata, err error)

	TransactionMetadata(id iotago.TransactionID) (transaction TransactionMetadata, exists bool)

	VM() VM

	InjectRequestedState(state State)

	TransactionMetadataByAttachment(blockID iotago.BlockID) (transaction TransactionMetadata, exists bool)

	CommitStateDiff(slot iotago.SlotIndex) (StateDiff, error)

	Evict(slot iotago.SlotIndex)

	// Reset resets the component to a clean state as if it was created at the last commitment.
	Reset()
}

type SignedTransaction interface {
	// ID returns the identifier of the Transaction that contains a signature.
	ID() (iotago.SignedTransactionID, error)
	// MustID works like ID but panics if the SignedTransactionID can't be computed.
	MustID() iotago.SignedTransactionID
}

type SignedTransactionMetadata interface {
	ID() iotago.SignedTransactionID

	SignedTransaction() SignedTransaction

	OnSignaturesValid(callback func()) (unsubscribe func())

	OnSignaturesInvalid(callback func(err error)) (unsubscribe func())

	SignaturesInvalid() error

	TransactionMetadata() TransactionMetadata

	Attachments() []iotago.BlockID
}

type State interface {
	// The identifier of the state.
	StateID() StateID

	// The type of state.
	Type() StateType

	// Whether the state is read only.
	IsReadOnly() bool

	// SlotBooked returns the slot index of the state if it is booked.
	SlotBooked() iotago.SlotIndex
}

type StateDiff interface {
	// Slot returns the slot index of the state diff.
	Slot() iotago.SlotIndex

	// DestroyedStates returns a compacted list of all the states that were destroyed in the slot.
	DestroyedStates() *shrinkingmap.ShrinkingMap[StateID, StateMetadata]

	// CreatedStates returns a compacted list of all the states that were created in the slot.
	CreatedStates() *shrinkingmap.ShrinkingMap[StateID, StateMetadata]

	// ExecutedTransactions returns an un-compacted list of all the transactions that were executed in the slot.
	ExecutedTransactions() *orderedmap.OrderedMap[iotago.TransactionID, TransactionMetadata]

	// Mutations returns an authenticated data structure that allows to commit to the applied mutations.
	Mutations() ads.Set[iotago.Identifier, iotago.TransactionID]

	// Reset resets the component to a clean state as if it was created at the last commitment.
	Reset() error
}

type StateID = iotago.Identifier

type StateMetadata interface {
	State() State

	SpenderIDs() reactive.Set[iotago.TransactionID]

	PendingSpenderCount() int

	AcceptedSpender() (TransactionMetadata, bool)

	OnAcceptedSpenderUpdated(callback func(spender TransactionMetadata))

	InclusionSlot() iotago.SlotIndex

	OnInclusionSlotUpdated(callback func(prevSlot iotago.SlotIndex, newSlot iotago.SlotIndex))
	// contains filtered or unexported methods
}

type StateReference interface {
	// The identifier of the state to which it resolves.
	ReferencedStateID() iotago.Identifier

	// The type of state.
	Type() StateType
}

type StateResolver func(reference StateReference) *promise.Promise[State]

type StateType byte

type Transaction interface {
	// ID returns the identifier of the Transaction.
	ID() (iotago.TransactionID, error)
	// MustID works like ID but panics if the TransactionID can't be computed.
	MustID() iotago.TransactionID
}

type TransactionMetadata interface {
	ID() iotago.TransactionID

	Transaction() Transaction

	Inputs() ds.Set[StateMetadata]

	Outputs() ds.Set[StateMetadata]

	SpenderIDs() reactive.Set[iotago.TransactionID]

	Commit()

	IsSolid() bool

	OnSolid(callback func())

	IsExecuted() bool

	OnExecuted(callback func())

	IsInvalid() bool

	OnInvalid(callback func(error))

	IsBooked() bool

	OnBooked(callback func())

	ValidAttachments() []iotago.BlockID

	EarliestIncludedAttachment() iotago.BlockID

	OnEarliestIncludedAttachmentUpdated(callback func(prevID, newID iotago.BlockID))

	OnEvicted(callback func())
	// contains filtered or unexported methods
}

type UTXOInputStateRef struct {
	Input *iotago.UTXOInput
}

type VM interface {
	// Inputs returns the referenced inputs of the given transaction.
	Inputs(transaction Transaction) ([]StateReference, error)

	// ValidateSignatures validates the signatures of the given SignedTransaction and returns the execution context.
	ValidateSignatures(signedTransaction SignedTransaction, inputs []State) (executionContext context.Context, err error)

	// Execute executes the transaction in the given execution context and returns the resulting states.
	Execute(executionContext context.Context, transaction Transaction) (outputs []State, err error)
}