tangle

package

Go to main page

Versions in this module

v0

v0.9.3

Jul 19, 2022

Changes in this version

type BlockID

+ EpochIndex epoch.Index

+ Identifier types.Identifier

+ func (b *BlockID) FromBase58(base58EncodedString string) (err error)

+ func (b *BlockID) FromBytes(serialized []byte) (consumedBytes int, err error)

+ func (b *BlockID) FromRandomness(optionalEpoch ...epoch.Index) (err error)

+ func (b BlockID) Alias() (alias string)

+ func (b BlockID) Base58() (base58Encoded string)

+ func (b BlockID) Bytes() (serialized []byte)

+ func (b BlockID) RegisterAlias(alias string)

+ func (b BlockID) UnregisterAlias()

v0.9.2

Jul 14, 2022

Changes in this version

+ const BlockIDLength

+ const BlockVersion

+ const ChildTypeLength

+ const MaxBlockSize

+ const PrefixBlock

+ const PrefixBlockMetadata

+ const PrefixChildren

+ const PrefixConflictVoters

+ const PrefixConflictWeight

+ const PrefixLatestConflictVotes

+ const PrefixMarkerBlockMapping

+ const PrefixMarkerConflictIDMapping

+ const PrefixMissingBlock

+ var ErrBlockTooSmall = errors.New("block too small")

+ var ErrInvalidBlockAndTransactionTimestamp = fmt.Errorf("invalid block and transaction timestamp")

+ var MarkerBlockMappingPartitionKeys = objectstorage.PartitionKey(markers.SequenceID(0).Length(), markers.Index(0).Length())

+ var ParentTypeToChildType = map[ParentsType]ChildType

+ func BlockIDToContext(ctx context.Context, blockID BlockID) context.Context

+ func IssueAndValidateBlockApproval(t *testing.T, blockAlias string, eventMock *EventMock, ...)

type ApprovalWeightManager

+ func (a *ApprovalWeightManager) VotersOfConflict(conflictID utxo.TransactionID) (voters *Voters)

+ func (a *ApprovalWeightManager) WeightOfConflict(conflictID utxo.TransactionID) (weight float64)

type ApprovalWeightManagerEvents

+ BlockProcessed *event.Event[*BlockProcessedEvent]

+ ConflictWeightChanged *event.Event[*ConflictWeightChangedEvent]

type Attachment

+ func (a *Attachment) BlockID() BlockID

+ type Block struct

+ func NewBlock(references ParentBlockIDs, issuingTime time.Time, ...) *Block

+ func NewBlockWithValidation(references ParentBlockIDs, issuingTime time.Time, ...) (result *Block, err error)

+ func (m *Block) DetermineID() (err error)

+ func (m *Block) ECR() epoch.ECR

+ func (m *Block) EI() epoch.Index

+ func (m *Block) ForEachParent(consumer func(parent Parent))

+ func (m *Block) ForEachParentByType(parentType ParentsType, consumer func(parentBlockID BlockID) bool)

+ func (m *Block) IDBytes() []byte

+ func (m *Block) IssuerPublicKey() ed25519.PublicKey

+ func (m *Block) IssuingTime() time.Time

+ func (m *Block) LatestConfirmedEpoch() epoch.Index

+ func (m *Block) Nonce() uint64

+ func (m *Block) Parents() (parents []BlockID)

+ func (m *Block) ParentsByType(parentType ParentsType) BlockIDs

+ func (m *Block) ParentsCountByType(parentType ParentsType) uint8

+ func (m *Block) Payload() payload.Payload

+ func (m *Block) PrevEC() epoch.EC

+ func (m *Block) SequenceNumber() uint64

+ func (m *Block) Signature() ed25519.Signature

+ func (m *Block) Size() int

+ func (m *Block) String() string

+ func (m *Block) VerifySignature() (valid bool, err error)

+ func (m *Block) Version() uint8

+ type BlockAcceptedEvent struct

+ Block *Block

+ type BlockBookedEvent struct

+ BlockID BlockID

+ type BlockConflictUpdatedEvent struct

+ BlockID BlockID

+ ConflictID utxo.TransactionID

+ type BlockConstructedEvent struct

+ Block *Block

+ type BlockDiscardedEvent struct

+ BlockID BlockID

+ type BlockDispatchedEvent struct

+ BlockID BlockID

+ type BlockFactory struct

+ Events *BlockFactoryEvents

+ ReferenceProvider *ReferenceProvider

+ func NewBlockFactory(tangle *Tangle, selector TipSelector, referencesFunc ...ReferencesFunc) *BlockFactory

+ func (f *BlockFactory) EarliestAttachment(transactionIDs utxo.TransactionIDs, earliestAttachmentMustBeBooked ...bool) (earliestAttachment *Block)

+ func (f *BlockFactory) IssuePayload(p payload.Payload, parentsCount ...int) (*Block, error)

+ func (f *BlockFactory) IssuePayloadWithReferences(p payload.Payload, references ParentBlockIDs, parentsCount ...int) (*Block, error)

+ func (f *BlockFactory) LatestAttachment(transactionID utxo.TransactionID) (latestAttachment *Block)

+ func (f *BlockFactory) SetTimeout(timeout time.Duration)

+ func (f *BlockFactory) SetWorker(worker Worker)

+ func (f *BlockFactory) Shutdown()

+ type BlockFactoryEvents struct

+ BlockConstructed *event.Event[*BlockConstructedEvent]

+ Error *event.Event[error]

+ func NewBlockFactoryEvents() (new *BlockFactoryEvents)

+ type BlockFilter interface

+ Filter func(blk *Block, peer *peer.Peer)

+ OnAccept func(callback func(blk *Block, peer *peer.Peer))

+ OnReject func(callback func(blk *Block, err error, peer *peer.Peer))

+ type BlockID struct

+ var EmptyBlockID BlockID

+ func BlockIDFromContext(ctx context.Context) BlockID

+ func NewBlockID(bytes [32]byte) (new BlockID)

+ func (m BlockID) CompareTo(other BlockID) int

+ func (m BlockID) Length() int

+ func (m BlockID) String() (humanReadable string)

+ type BlockIDs map[BlockID]types.Empty

+ func NewBlockIDs(blkIDs ...BlockID) BlockIDs

+ func (m BlockIDs) Add(blockID BlockID) BlockIDs

+ func (m BlockIDs) AddAll(blockIDs BlockIDs) BlockIDs

+ func (m BlockIDs) Base58() (result []string)

+ func (m BlockIDs) Clone() (clonedBlockIDs BlockIDs)

+ func (m BlockIDs) Contains(target BlockID) (contains bool)

+ func (m BlockIDs) Empty() (empty bool)

+ func (m BlockIDs) First() BlockID

+ func (m BlockIDs) Slice() []BlockID

+ func (m BlockIDs) String() string

+ func (m BlockIDs) Subtract(other BlockIDs) BlockIDs

+ type BlockInvalidEvent struct

+ BlockID BlockID

+ Error error

+ type BlockMetadata struct

+ func NewBlockMetadata(blockID BlockID) *BlockMetadata

+ func (m *BlockMetadata) AddConflictID(conflictID utxo.TransactionID) (modified bool)

+ func (m *BlockMetadata) AddedConflictIDs() utxo.TransactionIDs

+ func (m *BlockMetadata) BookedTime() time.Time

+ func (m *BlockMetadata) ConfirmationState() (result confirmation.State)

+ func (m *BlockMetadata) ConfirmationStateTime() time.Time

+ func (m *BlockMetadata) DiscardedTime() time.Time

+ func (m *BlockMetadata) IsBooked() (result bool)

+ func (m *BlockMetadata) IsObjectivelyInvalid() (result bool)

+ func (m *BlockMetadata) IsSolid() (result bool)

+ func (m *BlockMetadata) IsSubjectivelyInvalid() (result bool)

+ func (m *BlockMetadata) QueuedTime() time.Time

+ func (m *BlockMetadata) ReceivedTime() time.Time

+ func (m *BlockMetadata) Scheduled() bool

+ func (m *BlockMetadata) ScheduledTime() time.Time

+ func (m *BlockMetadata) SetAddedConflictIDs(addedConflictIDs utxo.TransactionIDs) (modified bool)

+ func (m *BlockMetadata) SetBooked(booked bool) (modified bool)

+ func (m *BlockMetadata) SetConfirmationState(confirmationState confirmation.State) (modified bool)

+ func (m *BlockMetadata) SetDiscardedTime(discardedTime time.Time)

+ func (m *BlockMetadata) SetObjectivelyInvalid(invalid bool) (modified bool)

+ func (m *BlockMetadata) SetQueuedTime(queuedTime time.Time)

+ func (m *BlockMetadata) SetScheduled(scheduled bool) (modified bool)

+ func (m *BlockMetadata) SetSolid(solid bool) (modified bool)

+ func (m *BlockMetadata) SetStructureDetails(structureDetails *markers.StructureDetails) (modified bool)

+ func (m *BlockMetadata) SetSubjectivelyInvalid(invalid bool) (modified bool)

+ func (m *BlockMetadata) SetSubtractedConflictIDs(subtractedConflictIDs utxo.TransactionIDs) (modified bool)

+ func (m *BlockMetadata) SolidificationTime() time.Time

+ func (m *BlockMetadata) StructureDetails() *markers.StructureDetails

+ func (m *BlockMetadata) SubtractedConflictIDs() utxo.TransactionIDs

+ type BlockMissingEvent struct

+ BlockID BlockID

+ type BlockModel struct

+ ECR epoch.ECR

+ EI epoch.Index

+ IssuerPublicKey ed25519.PublicKey

+ IssuingTime time.Time

+ LatestConfirmedEpoch epoch.Index

+ Nonce uint64

+ Parents ParentBlockIDs

+ PayloadBytes []byte

+ PrevEC epoch.EC

+ SequenceNumber uint64

+ Signature ed25519.Signature

+ Version uint8

+ type BlockOption func(*BlockTestFrameworkBlockOptions)

+ func WithECRecord(ecRecord *epoch.ECRecord) BlockOption

+ func WithLatestConfirmedEpoch(ei epoch.Index) BlockOption

+ type BlockParsedEvent struct

+ Block *Block

+ Peer *peer.Peer

+ type BlockProcessedEvent struct

+ BlockID BlockID

+ type BlockRejectedEvent struct

+ Block *Block

+ Error error

+ Peer *peer.Peer

+ type BlockRemovedEvent struct

+ BlockID BlockID

+ type BlockScheduledEvent struct

+ BlockID BlockID

+ type BlockSignatureFilter struct

+ func NewBlockSignatureFilter() *BlockSignatureFilter

+ func (f *BlockSignatureFilter) Close() error

+ func (f *BlockSignatureFilter) Filter(blk *Block, peer *peer.Peer)

+ func (f *BlockSignatureFilter) OnAccept(callback func(blk *Block, peer *peer.Peer))

+ func (f *BlockSignatureFilter) OnReject(callback func(blk *Block, err error, peer *peer.Peer))

+ type BlockSkippedEvent struct

+ BlockID BlockID

+ type BlockSolidEvent struct

+ Block *Block

+ type BlockStoredEvent struct

+ Block *Block

+ type BlockTestFramework struct

+ func NewBlockTestFramework(tangle *Tangle, options ...BlockTestFrameworkOption) (blockTestFramework *BlockTestFramework)

+ func (m *BlockTestFramework) Block(alias string) (block *Block)

+ func (m *BlockTestFramework) BlockIDs(aliases ...string) (blockIDs BlockIDs)

+ func (m *BlockTestFramework) BlockMetadata(alias string) (blockMetadata *BlockMetadata)

+ func (m *BlockTestFramework) Conflict(blockAlias string) (b *conflictdag.Conflict[utxo.TransactionID, utxo.OutputID])

+ func (m *BlockTestFramework) ConflictID(alias string) (conflictID utxo.TransactionID)

+ func (m *BlockTestFramework) ConflictIDFromBlock(blockAlias string) utxo.TransactionID

+ func (m *BlockTestFramework) ConflictIDs(aliases ...string) (conflictIDs utxo.TransactionIDs)

+ func (m *BlockTestFramework) CreateBlock(blockAlias string, blockOptions ...BlockOption) (block *Block)

+ func (m *BlockTestFramework) IncreaseMarkersIndexCallback(markers.SequenceID, markers.Index) bool

+ func (m *BlockTestFramework) IssueBlocks(blockAliases ...string) *BlockTestFramework

+ func (m *BlockTestFramework) LatestCommitment(blockAliases ...string) (ecRecord *epoch.ECRecord, latestConfirmedEpoch epoch.Index, err error)

+ func (m *BlockTestFramework) Output(alias string) (output devnetvm.Output)

+ func (m *BlockTestFramework) OutputMetadata(outputID utxo.OutputID) (outMeta *ledger.OutputMetadata)

+ func (m *BlockTestFramework) PreventNewMarkers(enabled bool) *BlockTestFramework

+ func (m *BlockTestFramework) RegisterConflictID(alias, blockAlias string)

+ func (m *BlockTestFramework) RegisterTransactionID(alias, blockAlias string)

+ func (m *BlockTestFramework) Snapshot() (snapshot *ledger.Snapshot)

+ func (m *BlockTestFramework) Transaction(blockAlias string) (tx utxo.Transaction)

+ func (m *BlockTestFramework) TransactionID(blockAlias string) utxo.TransactionID

+ func (m *BlockTestFramework) TransactionMetadata(blockAlias string) (txMeta *ledger.TransactionMetadata)

+ func (m *BlockTestFramework) WaitUntilAllTasksProcessed() (self *BlockTestFramework)

+ type BlockTestFrameworkBlockOptions struct

+ func NewBlockTestFrameworkBlockOptions(options ...BlockOption) (blockOptions *BlockTestFrameworkBlockOptions)

+ type BlockTestFrameworkOption func(*BlockTestFrameworkOptions)

+ type BlockTestFrameworkOptions struct

+ func NewBlockTestFrameworkOptions(options ...BlockTestFrameworkOption) (frameworkOptions *BlockTestFrameworkOptions)

type Booker

+ func (b *Booker) BlockConflictIDs(blockID BlockID) (conflictIDs *set.AdvancedSet[utxo.TransactionID], err error)

+ func (b *Booker) BookBlock(block *Block, blockMetadata *BlockMetadata) (err error)

+ func (b *Booker) PayloadConflictIDs(blockID BlockID) (conflictIDs *set.AdvancedSet[utxo.TransactionID], err error)

+ func (b *Booker) PropagateForkedConflict(transactionID utxo.TransactionID, addedConflictID utxo.TransactionID, ...) (err error)

type BookerEvents

+ BlockBooked *event.Event[*BlockBookedEvent]

+ BlockConflictUpdated *event.Event[*BlockConflictUpdatedEvent]

+ MarkerConflictAdded *event.Event[*MarkerConflictAddedEvent]

+ type BootstrappedEvent struct

+ type Child struct

+ func NewChild(childType ChildType, referencedBlockID BlockID, childBlockID BlockID) *Child

+ func (a *Child) ChildBlockID() BlockID

+ func (a *Child) ReferencedBlockID() BlockID

+ func (a *Child) Type() ChildType

+ type ChildType uint8

+ const ShallowLikeChild

+ const StrongChild

+ const WeakChild

+ func (a ChildType) Bytes() []byte

+ func (a ChildType) String() string

type ConfirmationEvents

+ BlockAccepted *event.Event[*BlockAcceptedEvent]

+ BlockOrphaned *event.Event[*BlockAcceptedEvent]

type ConfirmationOracle

+ IsBlockConfirmed func(blkID BlockID) bool

+ IsConflictConfirmed func(conflictID utxo.TransactionID) bool

+ type ConflictMarkersMapper struct

+ func NewConflictMarkersMapper(tangle *Tangle) (b *ConflictMarkersMapper)

+ func (b *ConflictMarkersMapper) BlockID(marker markers.Marker) (blockID BlockID)

+ func (b *ConflictMarkersMapper) Ceiling(referenceMarker markers.Marker) (marker markers.Index, conflictIDs *set.AdvancedSet[utxo.TransactionID], ...)

+ func (b *ConflictMarkersMapper) ConflictIDs(marker markers.Marker) (conflictIDs *set.AdvancedSet[utxo.TransactionID])

+ func (b *ConflictMarkersMapper) Floor(referenceMarker markers.Marker) (marker markers.Index, conflictIDs *set.AdvancedSet[utxo.TransactionID], ...)

+ func (b *ConflictMarkersMapper) ForEachConflictIDMapping(sequenceID markers.SequenceID, thresholdIndex markers.Index, ...)

+ func (b *ConflictMarkersMapper) ForEachMarkerReferencingMarker(referencedMarker markers.Marker, ...)

+ func (b *ConflictMarkersMapper) InheritStructureDetails(block *Block, structureDetails []*markers.StructureDetails) (newStructureDetails *markers.StructureDetails, newSequenceCreated bool)

+ func (b *ConflictMarkersMapper) SetBlockID(marker markers.Marker, blockID BlockID)

+ func (b *ConflictMarkersMapper) SetConflictIDs(marker markers.Marker, conflictIDs *set.AdvancedSet[utxo.TransactionID]) (updated bool)

+ type ConflictVote struct

+ func NewConflictVote(voter Voter, votePower VotePower, conflictID utxo.TransactionID, ...) (voteWithOpinion *ConflictVote)

+ func (v *ConflictVote) ConflictID() utxo.TransactionID

+ func (v *ConflictVote) Opinion() Opinion

+ func (v *ConflictVote) VotePower() VotePower

+ func (v *ConflictVote) Voter() Voter

+ func (v *ConflictVote) WithConflictID(conflictID utxo.TransactionID) (rejectedVote *ConflictVote)

+ func (v *ConflictVote) WithOpinion(opinion Opinion) (voteWithOpinion *ConflictVote)

+ type ConflictVoters struct

+ func NewConflictVoters(conflictID utxo.TransactionID) (conflictVoters *ConflictVoters)

+ func (b *ConflictVoters) AddVoter(voter Voter) (added bool)

+ func (b *ConflictVoters) AddVoters(voters *Voters) (added bool)

+ func (b *ConflictVoters) ConflictID() (conflictID utxo.TransactionID)

+ func (b *ConflictVoters) DeleteVoter(voter Voter) (deleted bool)

+ func (b *ConflictVoters) Has(voter Voter) bool

+ func (b *ConflictVoters) Voters() (voters *Voters)

+ type ConflictWeight struct

+ func NewConflictWeight(conflictID utxo.TransactionID) (conflictWeight *ConflictWeight)

+ func (b *ConflictWeight) ConflictID() (conflictID utxo.TransactionID)

+ func (b *ConflictWeight) SetWeight(weight float64) bool

+ func (b *ConflictWeight) Weight() (weight float64)

+ type ConflictWeightChangedEvent struct

+ ConflictID utxo.TransactionID

+ Weight float64

type DBStatsResult

+ MissingBlockCount int

type DispatcherEvents

+ BlockDispatched *event.Event[*BlockDispatchedEvent]

type EventMock

+ func (e *EventMock) BlockProcessed(event *BlockProcessedEvent)

+ func (e *EventMock) ConflictWeightChanged(event *ConflictWeightChangedEvent)

type Events

+ BlockInvalid *event.Event[*BlockInvalidEvent]

+ type LastBlock struct

+ BlockID BlockID

+ BlockTime time.Time

+ UpdateTime time.Time

+ func (l LastBlock) Bytes() (marshaledLastConfirmedBlock []byte)

+ func (l LastBlock) String() string

+ type LatestConflictVotes struct

+ func NewLatestConflictVotes(voter Voter) (latestConflictVotes *LatestConflictVotes)

+ func (l *LatestConflictVotes) Store(vote *ConflictVote) (stored bool)

+ func (l *LatestConflictVotes) Vote(conflictID utxo.TransactionID) (vote *ConflictVote, exists bool)

+ type MarkerBlockMapping struct

+ func NewMarkerBlockMapping(marker markers.Marker, blockID BlockID) *MarkerBlockMapping

+ func (m *MarkerBlockMapping) BlockID() BlockID

+ func (m *MarkerBlockMapping) Marker() *markers.Marker

+ type MarkerConflictAddedEvent struct

+ Marker markers.Marker

+ NewConflictID utxo.TransactionID

+ type MarkerIndexConflictIDMapping struct

+ func NewMarkerIndexConflictIDMapping(sequenceID markers.SequenceID) (markerConflictMapping *MarkerIndexConflictIDMapping)

+ func (m *MarkerIndexConflictIDMapping) Ceiling(index markers.Index) (marker markers.Index, conflictIDs utxo.TransactionIDs, exists bool)

+ func (m *MarkerIndexConflictIDMapping) ConflictIDs(markerIndex markers.Index) (conflictIDs utxo.TransactionIDs)

+ func (m *MarkerIndexConflictIDMapping) DeleteConflictID(index markers.Index)

+ func (m *MarkerIndexConflictIDMapping) Floor(index markers.Index) (marker markers.Index, conflictIDs utxo.TransactionIDs, exists bool)

+ func (m *MarkerIndexConflictIDMapping) SequenceID() markers.SequenceID

+ func (m *MarkerIndexConflictIDMapping) SetConflictIDs(index markers.Index, conflictIDs utxo.TransactionIDs)

+ type MissingBlock struct

+ func NewMissingBlock(blockID BlockID) *MissingBlock

+ func (m *MissingBlock) BlockID() BlockID

+ func (m *MissingBlock) MissingSince() time.Time

+ type MissingBlockStoredEvent struct

+ BlockID BlockID

type MockConfirmationOracle

+ func (m *MockConfirmationOracle) IsBlockConfirmed(blkID BlockID) bool

+ func (m *MockConfirmationOracle) IsConflictConfirmed(conflictID utxo.TransactionID) bool

type Option

+ func CommitmentFunc(commitmentRetrieverFunc func() (*epoch.ECRecord, epoch.Index, error)) Option

+ func GenesisTime(genesisTime time.Time) Option

type Options

+ CommitmentFunc func() (ecRecord *epoch.ECRecord, lastConfirmedEpochIndex epoch.Index, err error)

+ GenesisTime time.Time

+ type ParentBlockIDs map[ParentsType]BlockIDs

+ func NewParentBlockIDs() ParentBlockIDs

+ func (p ParentBlockIDs) Add(parentType ParentsType, blockID BlockID) ParentBlockIDs

+ func (p ParentBlockIDs) AddAll(parentType ParentsType, blockIDs BlockIDs) ParentBlockIDs

+ func (p ParentBlockIDs) AddStrong(blockID BlockID) ParentBlockIDs

+ func (p ParentBlockIDs) Clone() ParentBlockIDs

+ func (p ParentBlockIDs) IsEmpty() bool

type Parser

+ func (p *Parser) AddBlockFilter(filter BlockFilter)

type ParserEvents

+ BlockParsed *event.Event[*BlockParsedEvent]

+ BlockRejected *event.Event[*BlockRejectedEvent]

type RateSetterEvents

+ BlockDiscarded *event.Event[*BlockDiscardedEvent]

+ BlockIssued *event.Event[*BlockConstructedEvent]

type RequestFailedEvent

+ BlockID BlockID

type RequestIssuedEvent

+ BlockID BlockID

type RequestStartedEvent

+ BlockID BlockID

type RequestStoppedEvent

+ BlockID BlockID

type Scheduler

+ func (s *Scheduler) ReadyBlocksCount() int

+ func (s *Scheduler) TotalBlocksCount() int

type SchedulerEvents

+ BlockDiscarded *event.Event[*BlockDiscardedEvent]

+ BlockScheduled *event.Event[*BlockScheduledEvent]

+ BlockSkipped *event.Event[*BlockSkippedEvent]

type SchedulerParams

+ ConfirmedBlockScheduleThreshold time.Duration

type SimpleMockOnTangleVoting

+ func (o *SimpleMockOnTangleVoting) ConflictLiked(conflictID utxo.TransactionID) (conflictLiked bool)

type Solidifier

+ func (s *Solidifier) RetrieveMissingBlock(blockID BlockID) (blockWasMissing bool)

type SolidifierEvents

+ BlockMissing *event.Event[*BlockMissingEvent]

+ BlockSolid *event.Event[*BlockSolidEvent]

type Storage

+ func (s *Storage) AttachmentBlockIDs(transactionID utxo.TransactionID) (blockIDs BlockIDs)

+ func (s *Storage) Block(blockID BlockID) *objectstorage.CachedObject[*Block]

+ func (s *Storage) BlockMetadata(blockID BlockID, computeIfAbsentCallback ...func() *BlockMetadata) *objectstorage.CachedObject[*BlockMetadata]

+ func (s *Storage) Children(blockID BlockID, optionalChildType ...ChildType) (cachedChildren objectstorage.CachedObjects[*Child])

+ func (s *Storage) ConflictVoters(conflictID utxo.TransactionID, ...) *objectstorage.CachedObject[*ConflictVoters]

+ func (s *Storage) ConflictWeight(conflictID utxo.TransactionID, ...) *objectstorage.CachedObject[*ConflictWeight]

+ func (s *Storage) DeleteBlock(blockID BlockID)

+ func (s *Storage) DeleteMarkerBlockMapping(conflictID utxo.TransactionID, blockID BlockID)

+ func (s *Storage) DeleteMissingBlock(blockID BlockID)

+ func (s *Storage) IsTransactionAttachedByBlock(transactionID utxo.TransactionID, blockID BlockID) (attached bool)

+ func (s *Storage) LatestConflictVotes(voter Voter, computeIfAbsentCallback ...func(voter Voter) *LatestConflictVotes) *objectstorage.CachedObject[*LatestConflictVotes]

+ func (s *Storage) MarkerBlockMapping(marker markers.Marker) (cachedMarkerBlockMappings *objectstorage.CachedObject[*MarkerBlockMapping])

+ func (s *Storage) MarkerBlockMappings(sequenceID markers.SequenceID) (cachedMarkerBlockMappings objectstorage.CachedObjects[*MarkerBlockMapping])

+ func (s *Storage) MarkerIndexConflictIDMapping(sequenceID markers.SequenceID, ...) *objectstorage.CachedObject[*MarkerIndexConflictIDMapping]

+ func (s *Storage) MissingBlocks() (ids []BlockID)

+ func (s *Storage) StoreBlock(block *Block)

+ func (s *Storage) StoreMarkerBlockMapping(markerBlockMapping *MarkerBlockMapping)

+ func (s *Storage) StoreMissingBlock(missingBlock *MissingBlock) (cachedMissingBlock *objectstorage.CachedObject[*MissingBlock], stored bool)

type StorageEvents

+ BlockRemoved *event.Event[*BlockRemovedEvent]

+ BlockStored *event.Event[*BlockStoredEvent]

+ MissingBlockStored *event.Event[*MissingBlockStoredEvent]

type Tangle

+ BlockFactory *BlockFactory

+ func (t *Tangle) ProcessGossipBlock(blockBytes []byte, peer *peer.Peer)

type TestScenario

+ TestFramework *BlockTestFramework

+ func ProcessBlockScenario(t *testing.T, options ...Option) *TestScenario

+ func ProcessBlockScenario2(t *testing.T, options ...Option) *TestScenario

type TimeManager

+ func (t *TimeManager) ActivityTime() time.Time

+ func (t *TimeManager) LastAcceptedBlock() LastBlock

+ func (t *TimeManager) LastConfirmedBlock() LastBlock

type TimeManagerEvents

+ Bootstrapped *event.Event[*BootstrappedEvent]

type TimeUpdate

+ ATT time.Time

+ BlockID BlockID

+ UpdateTime time.Time

type TipEvent

+ BlockID BlockID

type Utils

+ func (u *Utils) AllConflictsLiked(conflictIDs *set.AdvancedSet[utxo.TransactionID]) bool

+ func (u *Utils) ApprovingBlockIDs(blockID BlockID, optionalChildType ...ChildType) (approvingBlockIDs BlockIDs)

+ func (u *Utils) WalkBlock(callback func(block *Block, walker *walker.Walker[BlockID]), ...)

+ func (u *Utils) WalkBlockAndMetadata(...)

+ func (u *Utils) WalkBlockID(callback func(blockID BlockID, walker *walker.Walker[BlockID]), ...)

+ func (u *Utils) WalkBlockMetadata(callback func(blockMetadata *BlockMetadata, walker *walker.Walker[BlockID]), ...)

v0.9.1

Jun 22, 2022

Changes in this version

+ const Wmax

+ const Wmin

+ var ErrNotBootstrapped = errors.New("tangle not bootstrapped")

+ type LastMessage struct

+ MessageID MessageID

+ MessageTime time.Time

+ UpdateTime time.Time

+ func (l LastMessage) Bytes() (marshaledLastConfirmedMessage []byte)

+ func (l LastMessage) String() string

+ type QueueElement struct

+ Key time.Time

+ Value MessageID

type RateSetter

+ func (r *RateSetter) Estimate() time.Duration

type RateSetterEvents

+ Error *event.Event[error]

+ MessageIssued *event.Event[*MessageConstructedEvent]

type RateSetterParams

+ Enabled bool

+ RateSettingPause time.Duration

type Scheduler

+ func (s *Scheduler) GetDeficit(nodeID identity.ID) *big.Rat

+ func (s *Scheduler) Quanta(nodeID identity.ID) *big.Rat

type Tangle

+ func (t *Tangle) Bootstrapped() bool

type TimeManager

+ func (t *TimeManager) ATT() time.Time

+ func (t *TimeManager) Bootstrapped() bool

+ func (t *TimeManager) CTT() time.Time

+ func (t *TimeManager) LastAcceptedMessage() LastMessage

+ func (t *TimeManager) RATT() time.Time

+ func (t *TimeManager) RCTT() time.Time

type TimeManagerEvents

+ AcceptanceTimeUpdated *event.Event[*TimeUpdate]

+ ConfirmedTimeUpdated *event.Event[*TimeUpdate]

+ type TimeUpdate struct

+ NewTime time.Time

+ type TimedHeap []*QueueElement

+ func (h *TimedHeap) Pop() interface{}

+ func (h *TimedHeap) Push(x interface{})

+ func (h TimedHeap) Len() int

+ func (h TimedHeap) Less(i, j int) bool

+ func (h TimedHeap) Swap(i, j int)

+ type TipsCleaner struct

+ func (t *TipsCleaner) Add(key time.Time, value MessageID)

+ func (t *TipsCleaner) RemoveBefore(minAllowedTime time.Time)

v0.9.0

Jun 16, 2022

Changes in this version

+ func MessageIDToContext(ctx context.Context, messageID MessageID) context.Context

+ type BlockOrphanedEvent struct

+ Block *Message

+ Reason error

type BookerEvents

+ func NewBookerEvents() (new *BookerEvents)

type BranchMarkersMapper

+ func (b *BranchMarkersMapper) BranchIDs(marker markers.Marker) (branchIDs *set.AdvancedSet[utxo.TransactionID])

type BranchVote

+ func NewBranchVote(voter Voter, votePower VotePower, branchID utxo.TransactionID, opinion Opinion) (voteWithOpinion *BranchVote)

type BytesRejectedEvent

+ Error error

type ConfirmationEvents

+ func NewConfirmationEvents() (new *ConfirmationEvents)

+ type MarkerBranchAddedEvent struct

+ Marker markers.Marker

+ NewBranchID utxo.TransactionID

type Message

+ func NewMessageWithValidation(references ParentMessageIDs, issuingTime time.Time, ...) (result *Message, err error)

+ func (m *Message) DetermineID() (err error)

+ type MessageBookedEvent struct

+ MessageID MessageID

+ type MessageBranchUpdatedEvent struct

+ BranchID utxo.TransactionID

+ MessageID MessageID

+ type MessageConfirmedEvent struct

+ Message *Message

+ type MessageConstructedEvent struct

+ Message *Message

+ type MessageDiscardedEvent struct

+ MessageID MessageID

+ type MessageDispatchedEvent struct

+ MessageID MessageID

type MessageFactory

+ ReferenceProvider *ReferenceProvider

+ func (f *MessageFactory) EarliestAttachment(transactionIDs utxo.TransactionIDs) (earliestAttachment *Message)

+ func (f *MessageFactory) LatestAttachment(transactionID utxo.TransactionID) (latestAttachment *Message)

type MessageFactoryEvents

+ func NewMessageFactoryEvents() (new *MessageFactoryEvents)

type MessageID

+ func MessageIDFromContext(ctx context.Context) MessageID

+ func (m MessageID) Length() int

+ type MessageMissingEvent struct

+ MessageID MessageID

+ type MessageModel struct

+ IssuerPublicKey ed25519.PublicKey

+ IssuingTime time.Time

+ Nonce uint64

+ Parents ParentMessageIDs

+ PayloadBytes []byte

+ SequenceNumber uint64

+ Signature ed25519.Signature

+ Version uint8

+ type MessageProcessedEvent struct

+ MessageID MessageID

type MessageRejectedEvent

+ Error error

+ type MessageRemovedEvent struct

+ MessageID MessageID

+ type MessageScheduledEvent struct

+ MessageID MessageID

+ type MessageSkippedEvent struct

+ MessageID MessageID

+ type MessageSolidEvent struct

+ Message *Message

+ type MessageStoredEvent struct

+ Message *Message

type MessageTestFramework

+ func (m *MessageTestFramework) MessageIDs(aliases ...string) (messageIDs MessageIDs)

+ func (m *MessageTestFramework) RegisterTransactionID(alias, messageAlias string)

+ func (m *MessageTestFramework) WaitUntilAllTasksProcessed() (self *MessageTestFramework)

+ type MissingMessageStoredEvent struct

+ MessageID MessageID

+ type NodeBlacklistedEvent struct

+ NodeID identity.ID

type Option

+ func WithConflictDAGOptions(branchDAGOptions ...conflictdag.Option) Option

type Options

+ ConflictDAGOptions []conflictdag.Option

+ type OrphanageManager struct

+ Events *OrphanageManagerEvents

+ func NewOrphanageManager(tangle *Tangle) *OrphanageManager

+ func (o *OrphanageManager) OrphanBlock(blockID MessageID, reason error)

+ func (o *OrphanageManager) Setup()

+ type OrphanageManagerEvents struct

+ AllChildrenOrphaned *event.Event[*Message]

+ BlockOrphaned *event.Event[*BlockOrphanedEvent]

type ParentMessageIDs

+ func (p ParentMessageIDs) IsEmpty() bool

+ type ReferenceProvider struct

+ func NewReferenceProvider(tangle *Tangle) (newInstance *ReferenceProvider)

+ func (r *ReferenceProvider) References(payload payload.Payload, strongParents MessageIDs, issuingTime time.Time) (references ParentMessageIDs, err error)

+ func (r *ReferenceProvider) ReferencesToMissingConflicts(issuingTime time.Time, amount int) (blockIDs MessageIDs)

+ type RequestFailedEvent struct

+ MessageID MessageID

+ type RequestIssuedEvent struct

+ MessageID MessageID

+ type RequestStartedEvent struct

+ MessageID MessageID

+ type RequestStoppedEvent struct

+ MessageID MessageID

type SchedulerEvents

+ func NewSchedulerEvents() (new *SchedulerEvents)

type SchedulerParams

+ TotalSupply int

type Tangle

+ Ledger *ledger.Ledger

+ OrphanageManager *OrphanageManager

+ type TipsConflictTracker struct

+ func NewTipsConflictTracker(tangle *Tangle) *TipsConflictTracker

+ func (c *TipsConflictTracker) AddTip(messageID MessageID)

+ func (c *TipsConflictTracker) MissingConflicts(amount int) (missingConflicts utxo.TransactionIDs)

+ func (c *TipsConflictTracker) RemoveTip(messageID MessageID)

+ func (c *TipsConflictTracker) Setup()

type Utils

+ func (u *Utils) ConfirmedConsumer(outputID utxo.OutputID) (consumerID utxo.TransactionID)

v0.8.14

May 16, 2022

v0.8.13

May 6, 2022

Changes in this version

type ActivityLog

+ func (a *ActivityLog) Decode(data []byte) (bytesRead int, err error)

+ func (a *ActivityLog) Encode() ([]byte, error)

+ type NodesActivityLog map[identity.ID]*ActivityLog

type Voters

+ func (v *Voters) Decode(data []byte) (bytesRead int, err error)

+ func (v *Voters) Encode() ([]byte, error)

v0.8.12

Apr 25, 2022

Changes in this version

type ConfirmationEvents

+ BranchGoFChanged *events.Event

+ TransactionGoFChanged *events.Event

v0.8.11

Mar 23, 2022

Changes in this version

type MessageFactoryEvents

+ MessageReferenceImpossible *events.Event

type MessageIDs

+ func (m MessageIDs) Empty() (empty bool)

+ func (m MessageIDs) Subtract(other MessageIDs) MessageIDs

v0.8.10

Mar 14, 2022

Changes in this version

+ var ParentTypeToApproverType = map[ParentsType]ApproverType

type ApprovalWeightManager

+ func (a *ApprovalWeightManager) VotersOfBranch(branchID ledgerstate.BranchID) (voters *Voters)

type Approver

+ func (a *Approver) FromBytes(bytes []byte) (result *Approver, err error)

+ func (a *Approver) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (approver *Approver, err error)

+ func (a *Approver) FromObjectStorage(key, _ []byte) (objectstorage.StorableObject, error)

type ApproverType

+ const ShallowDislikeApprover

+ const ShallowLikeApprover

type Attachment

+ func (a *Attachment) FromBytes(bytes []byte) (result *Attachment, err error)

+ func (a *Attachment) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (attachment *Attachment, err error)

+ func (a *Attachment) FromObjectStorage(key, _ []byte) (objectstorage.StorableObject, error)

type BranchMarkersMapper

+ func (b *BranchMarkersMapper) PendingBranchIDs(marker *markers.Marker) (branchIDs ledgerstate.BranchIDs, err error)

+ func (b *BranchMarkersMapper) SetBranchIDs(marker *markers.Marker, branchIDs ledgerstate.BranchIDs) (updated bool)

type BranchVoters

+ func (b *BranchVoters) FromBytes(bytes []byte) (branchVoters *BranchVoters, err error)

+ func (b *BranchVoters) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (branchVoters *BranchVoters, err error)

+ func (b *BranchVoters) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type BranchWeight

+ func (b *BranchWeight) FromBytes(bytes []byte) (branchWeight *BranchWeight, err error)

+ func (b *BranchWeight) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (branchWeight *BranchWeight, err error)

+ func (b *BranchWeight) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type LatestBranchVotes

+ func (l *LatestBranchVotes) FromBytes(bytes []byte) (latestBranchVotes *LatestBranchVotes, err error)

+ func (l *LatestBranchVotes) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (latestBranchVotes *LatestBranchVotes, err error)

+ func (l *LatestBranchVotes) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type LatestMarkerVotes

+ func (l *LatestMarkerVotes) FromBytes(bytes []byte) (latestMarkerVotes *LatestMarkerVotes, err error)

+ func (l *LatestMarkerVotes) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (latestMarkerVotes *LatestMarkerVotes, err error)

+ func (l *LatestMarkerVotes) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type LedgerState

+ func (l *LedgerState) BranchIDs(transactionID ledgerstate.TransactionID) (branchIDs ledgerstate.BranchIDs)

type MarkerIndexBranchIDMapping

+ func (m *MarkerIndexBranchIDMapping) BranchIDs(markerIndex markers.Index) (branchIDs ledgerstate.BranchIDs)

+ func (m *MarkerIndexBranchIDMapping) FromBytes(bytes []byte) (markerIndexBranchIDMapping objectstorage.StorableObject, err error)

+ func (m *MarkerIndexBranchIDMapping) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (markerIndexBranchIDMapping *MarkerIndexBranchIDMapping, err error)

+ func (m *MarkerIndexBranchIDMapping) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

+ func (m *MarkerIndexBranchIDMapping) SetBranchIDs(index markers.Index, branchIDs ledgerstate.BranchIDs)

type MarkerMessageMapping

+ func (m *MarkerMessageMapping) FromBytes(bytes []byte) (individuallyMappedMessage objectstorage.StorableObject, err error)

+ func (m *MarkerMessageMapping) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (markerMessageMapping *MarkerMessageMapping, err error)

+ func (m *MarkerMessageMapping) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type Message

+ func (m *Message) FromBytes(bytes []byte) (message *Message, err error)

+ func (m *Message) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (*Message, error)

+ func (m *Message) FromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

type MessageFactory

+ func (f *MessageFactory) IssuePayloadWithReferences(p payload.Payload, references ParentMessageIDs) (*Message, error)

type MessageIDs

+ func (m MessageIDs) Base58() (result []string)

+ func (m MessageIDs) Contains(target MessageID) (contains bool)

+ func (m MessageIDs) First() MessageID

+ func (m MessageIDs) String() string

type MessageMetadata

+ func (m *MessageMetadata) AddBranchID(branchID ledgerstate.BranchID) (modified bool)

+ func (m *MessageMetadata) FromBytes(bytes []byte) (result *MessageMetadata, err error)

+ func (m *MessageMetadata) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (messageMetadata *MessageMetadata, err error)

+ func (m *MessageMetadata) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type MissingMessage

+ func (m *MissingMessage) FromBytes(bytes []byte) (result *MissingMessage, err error)

+ func (m *MissingMessage) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *MissingMessage, err error)

+ func (m *MissingMessage) FromObjectStorage(key, bytes []byte) (objectstorage.StorableObject, error)

type Option

+ func TimeSinceConfirmationThreshold(tscThreshold time.Duration) Option

type Options

+ TimeSinceConfirmationThreshold time.Duration

v0.8.9

Mar 4, 2022

v0.8.8

Mar 1, 2022

v0.8.7

Feb 24, 2022

v0.8.6

Feb 11, 2022

Changes in this version

+ const LastValidBlockType

+ const PrefixBranchVoters

+ const PrefixLatestBranchVotes

+ const PrefixLatestMarkerVotes

+ var ErrConflictingReferenceAcrossBlocks = errors.New("different blocks have conflicting references")

+ var LatestMarkerVotesKeyPartition = objectstorage.PartitionKey(markers.SequenceIDLength, identity.IDLength)

+ func BranchVotersFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func LatestBranchVotesFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func LatestMarkerVotesFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

type ApprovalWeightManager

+ func (a *ApprovalWeightManager) VotersOfConflictBranch(branchID ledgerstate.BranchID) (voters *Voters)

type Booker

+ func (b *Booker) MessageBranchIDs(messageID MessageID) (branchIDs ledgerstate.BranchIDs, err error)

+ func (b *Booker) PayloadBranchIDs(messageID MessageID) (branchIDs ledgerstate.BranchIDs, err error)

+ func (b *Booker) PropagateForkedBranch(transactionID ledgerstate.TransactionID, forkedBranchID ledgerstate.BranchID) (err error)

type BookerEvents

+ MarkerBranchAdded *events.Event

+ type BranchMarkersMapper struct

+ Events *BranchMarkersMapperEvents

+ func NewBranchMarkersMapper(tangle *Tangle) (b *BranchMarkersMapper)

+ func (b *BranchMarkersMapper) BranchID(marker *markers.Marker) (branchID ledgerstate.BranchID)

+ func (b *BranchMarkersMapper) Ceiling(referenceMarker *markers.Marker) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ func (b *BranchMarkersMapper) ConflictBranchIDs(marker *markers.Marker) (branchIDs ledgerstate.BranchIDs, err error)

+ func (b *BranchMarkersMapper) Floor(referenceMarker *markers.Marker) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ func (b *BranchMarkersMapper) ForEachBranchIDMapping(sequenceID markers.SequenceID, thresholdIndex markers.Index, ...)

+ func (b *BranchMarkersMapper) ForEachMarkerReferencingMarker(referencedMarker *markers.Marker, ...)

+ func (b *BranchMarkersMapper) InheritStructureDetails(message *Message, structureDetails []*markers.StructureDetails) (newStructureDetails *markers.StructureDetails, newSequenceCreated bool)

+ func (b *BranchMarkersMapper) MessageID(marker *markers.Marker) (messageID MessageID)

+ func (b *BranchMarkersMapper) SetBranchID(marker *markers.Marker, branchID ledgerstate.BranchID) (updated bool)

+ func (b *BranchMarkersMapper) SetMessageID(marker *markers.Marker, messageID MessageID)

+ type BranchMarkersMapperEvents struct

+ FutureMarkerUpdated *events.Event

+ type BranchVote struct

+ BranchID ledgerstate.BranchID

+ Opinion Opinion

+ VotePower VotePower

+ Voter Voter

+ func VoteFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (vote *BranchVote, err error)

+ func (v *BranchVote) Bytes() []byte

+ func (v *BranchVote) String() string

+ func (v *BranchVote) WithBranchID(branchID ledgerstate.BranchID) (rejectedVote *BranchVote)

+ func (v *BranchVote) WithOpinion(opinion Opinion) (voteWithOpinion *BranchVote)

+ type BranchVoters struct

+ func BranchVotersFromBytes(bytes []byte) (branchVoters *BranchVoters, consumedBytes int, err error)

+ func BranchVotersFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (branchVoters *BranchVoters, err error)

+ func NewBranchVoters(branchID ledgerstate.BranchID) (branchVoters *BranchVoters)

+ func (b *BranchVoters) AddVoter(voter Voter) (added bool)

+ func (b *BranchVoters) AddVoters(voters *Voters) (added bool)

+ func (b *BranchVoters) BranchID() (branchID ledgerstate.BranchID)

+ func (b *BranchVoters) Bytes() (marshaledBranchVoters []byte)

+ func (b *BranchVoters) DeleteVoter(voter Voter) (deleted bool)

+ func (b *BranchVoters) Has(voter Voter) bool

+ func (b *BranchVoters) ObjectStorageKey() []byte

+ func (b *BranchVoters) ObjectStorageValue() []byte

+ func (b *BranchVoters) String() string

+ func (b *BranchVoters) Update(objectstorage.StorableObject)

+ func (b *BranchVoters) Voters() (voters *Voters)

type CManaWeightProvider

+ func (c *CManaWeightProvider) WeightsOfRelevantVoters() (weights map[identity.ID]float64, totalWeight float64)

+ type CachedBranchVoters struct

+ func (c *CachedBranchVoters) Consume(consumer func(branchVoters *BranchVoters), forceRelease ...bool) (consumed bool)

+ func (c *CachedBranchVoters) Retain() *CachedBranchVoters

+ func (c *CachedBranchVoters) String() string

+ func (c *CachedBranchVoters) Unwrap() *BranchVoters

+ type CachedLatestBranchVotes struct

+ func (c *CachedLatestBranchVotes) Consume(consumer func(latestBranchVotes *LatestBranchVotes), forceRelease ...bool) (consumed bool)

+ func (c *CachedLatestBranchVotes) Retain() *CachedLatestBranchVotes

+ func (c *CachedLatestBranchVotes) String() string

+ func (c *CachedLatestBranchVotes) Unwrap() *LatestBranchVotes

+ type CachedLatestMarkerVotes struct

+ func (c *CachedLatestMarkerVotes) Consume(consumer func(latestMarkerVotes *LatestMarkerVotes), forceRelease ...bool) (consumed bool)

+ func (c *CachedLatestMarkerVotes) Retain() *CachedLatestMarkerVotes

+ func (c *CachedLatestMarkerVotes) String() string

+ func (c *CachedLatestMarkerVotes) Unwrap() *LatestMarkerVotes

+ type CachedLatestMarkerVotesByVoter map[Voter]*CachedLatestMarkerVotes

+ func (c CachedLatestMarkerVotesByVoter) Consume(consumer func(latestMarkerVotes *LatestMarkerVotes), forceRelease ...bool) (consumed bool)

type ConfirmationOracle

+ FirstUnconfirmedMarkerIndex func(sequenceID markers.SequenceID) (unconfirmedMarkerIndex markers.Index)

+ type FutureMarkerUpdate struct

+ FutureMarker MessageID

+ ID MessageID

+ type LatestBranchVotes struct

+ func LatestBranchVotesFromBytes(bytes []byte) (latestBranchVotes *LatestBranchVotes, consumedBytes int, err error)

+ func LatestBranchVotesFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (latestBranchVotes *LatestBranchVotes, err error)

+ func NewLatestBranchVotes(voter Voter) (latestBranchVotes *LatestBranchVotes)

+ func (l *LatestBranchVotes) Bytes() []byte

+ func (l *LatestBranchVotes) ObjectStorageKey() []byte

+ func (l *LatestBranchVotes) ObjectStorageValue() []byte

+ func (l *LatestBranchVotes) Store(vote *BranchVote) (stored bool)

+ func (l *LatestBranchVotes) String() string

+ func (l *LatestBranchVotes) Update(objectstorage.StorableObject)

+ func (l *LatestBranchVotes) Vote(branchID ledgerstate.BranchID) (vote *BranchVote, exists bool)

+ type LatestMarkerVotes struct

+ func LatestMarkerVotesFromBytes(bytes []byte) (latestMarkerVotes *LatestMarkerVotes, consumedBytes int, err error)

+ func LatestMarkerVotesFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (latestMarkerVotes *LatestMarkerVotes, err error)

+ func NewLatestMarkerVotes(sequenceID markers.SequenceID, voter Voter) (newLatestMarkerVotes *LatestMarkerVotes)

+ func (l *LatestMarkerVotes) Bytes() []byte

+ func (l *LatestMarkerVotes) ObjectStorageKey() []byte

+ func (l *LatestMarkerVotes) ObjectStorageValue() []byte

+ func (l *LatestMarkerVotes) Power(index markers.Index) (power VotePower, exists bool)

+ func (l *LatestMarkerVotes) Store(index markers.Index, power VotePower) (stored bool, previousHighestIndex markers.Index)

+ func (l *LatestMarkerVotes) String() string

+ func (l *LatestMarkerVotes) Update(objectstorage.StorableObject)

+ func (l *LatestMarkerVotes) Voter() Voter

type LedgerState

+ func (l *LedgerState) Setup()

+ type LikedConflictMembers struct

type MessageIDs

+ func NewMessageIDs(msgIDs ...MessageID) MessageIDs

+ func (m MessageIDs) Add(messageID MessageID) MessageIDs

+ func (m MessageIDs) AddAll(messageIDs MessageIDs) MessageIDs

+ func (m MessageIDs) Clone() (clonedMessageIDs MessageIDs)

+ func (m MessageIDs) Slice() MessageIDsSlice

+ type MessageIDsSlice []MessageID

+ func (ids MessageIDsSlice) ToMessageIDs() MessageIDs

+ func (ids MessageIDsSlice) ToStrings() []string

type MessageMetadata

+ func (m *MessageMetadata) AddedBranchIDs() ledgerstate.BranchID

+ func (m *MessageMetadata) IsObjectivelyInvalid() (result bool)

+ func (m *MessageMetadata) IsSubjectivelyInvalid() (result bool)

+ func (m *MessageMetadata) SetAddedBranchIDs(aggregatedAddedBranchIDs ledgerstate.BranchID) (modified bool)

+ func (m *MessageMetadata) SetObjectivelyInvalid(invalid bool) (modified bool)

+ func (m *MessageMetadata) SetSubjectivelyInvalid(invalid bool) (modified bool)

+ func (m *MessageMetadata) SetSubtractedBranchIDs(aggregatedSubtractedBranchIDs ledgerstate.BranchID) (modified bool)

+ func (m *MessageMetadata) SubtractedBranchIDs() ledgerstate.BranchID

type MessageOption

+ func WithSequenceNumber(sequenceNumber uint64) MessageOption

+ func WithShallowDislikeParents(messageAliases ...string) MessageOption

+ func WithShallowLikeParents(messageAliases ...string) MessageOption

type MessageTestFramework

+ func (m *MessageTestFramework) BranchIDs(aliases ...string) (branchIDs ledgerstate.BranchIDs)

type MockConfirmationOracle

+ func (m *MockConfirmationOracle) FirstUnconfirmedMarkerIndex(sequenceID markers.SequenceID) (unconfirmedMarkerIndex markers.Index)

type MockWeightProvider

+ func (m *MockWeightProvider) WeightsOfRelevantVoters() (weights map[identity.ID]float64, totalWeight float64)

type Opinion

+ const Confirmed

+ const Rejected

+ const UndefinedOpinion

type Option

+ func MergeBranches(mergeBranches bool) Option

type Options

+ LedgerState struct{ ... }

+ type ParentMessageIDs map[ParentsType]MessageIDs

+ func NewParentMessageIDs() ParentMessageIDs

+ func PrepareReferences(strongParents MessageIDsSlice, issuingTime time.Time, tangle *Tangle) (references ParentMessageIDs, err error)

+ func (p ParentMessageIDs) Add(parentType ParentsType, messageID MessageID) ParentMessageIDs

+ func (p ParentMessageIDs) AddAll(parentType ParentsType, messageIDs MessageIDs) ParentMessageIDs

+ func (p ParentMessageIDs) AddStrong(messageID MessageID) ParentMessageIDs

+ func (p ParentMessageIDs) Clone() ParentMessageIDs

type ParentsType

+ const ShallowDislikeParentType

+ const ShallowLikeParentType

+ const UndefinedParentType

+ type ReferencesFunc func(strongParents MessageIDsSlice, issuingTime time.Time, tangle *Tangle) (references ParentMessageIDs, err error)

type SimpleMockOnTangleVoting

+ func (o *SimpleMockOnTangleVoting) BranchLiked(branchID ledgerstate.BranchID) (branchLiked bool)

+ func (o *SimpleMockOnTangleVoting) LikedConflictMember(branchID ledgerstate.BranchID) (likedBranchID ledgerstate.BranchID, conflictMembers ledgerstate.BranchIDs)

type Storage

+ func (s *Storage) AllLatestMarkerVotes(sequenceID markers.SequenceID) (cachedLatestMarkerVotesByVoter CachedLatestMarkerVotesByVoter)

+ func (s *Storage) BranchVoters(branchID ledgerstate.BranchID, ...) *CachedBranchVoters

+ func (s *Storage) LatestBranchVotes(voter Voter, computeIfAbsentCallback ...func(voter Voter) *LatestBranchVotes) *CachedLatestBranchVotes

+ func (s *Storage) LatestMarkerVotes(sequenceID markers.SequenceID, voter Voter, ...) *CachedLatestMarkerVotes

type TestScenario

+ func ProcessMessageScenario2(t *testing.T) *TestScenario

type Utils

+ func (u *Utils) AllBranchesLiked(branchIDs ledgerstate.BranchIDs) bool

+ type VotePower = uint64

+ type Voter = identity.ID

+ type Voters struct

+ func NewVoters() (voters *Voters)

+ func (v *Voters) Add(voter Voter) (added bool)

+ func (v *Voters) AddAll(voters *Voters)

+ func (v *Voters) Clone() (clonedVoters *Voters)

+ func (v *Voters) Delete(voter Voter) (deleted bool)

+ func (v *Voters) ForEach(callback func(voter Voter))

+ func (v *Voters) Has(voter Voter) (has bool)

+ func (v *Voters) Intersect(other *Voters) (intersection *Voters)

+ func (v *Voters) String() string

type WeightProvider

+ WeightsOfRelevantVoters func() (weights map[identity.ID]float64, totalWeight float64)

v0.8.5

Jan 19, 2022

v0.8.4

Jan 12, 2022

Changes in this version

+ type DBStatsResult struct

+ BookedCount int

+ MissingMessageCount int

+ ScheduledCount int

+ SolidCount int

+ StoredCount int

+ SumBookedReceivedTime time.Duration

+ SumSchedulerBookedTime time.Duration

+ SumSchedulerReceivedTime time.Duration

+ SumSolidificationReceivedTime time.Duration

+ type Dispatcher struct

+ Events *DispatcherEvents

+ func NewDispatcher(tangle *Tangle) (dispatcher *Dispatcher)

+ func (d *Dispatcher) Setup()

+ func (d *Dispatcher) Shutdown()

+ type DispatcherEvents struct

+ MessageDispatched *events.Event

type MessageMetadata

+ func (m *MessageMetadata) DiscardedTime() time.Time

+ func (m *MessageMetadata) QueuedTime() time.Time

+ func (m *MessageMetadata) SetDiscardedTime(discardedTime time.Time)

+ func (m *MessageMetadata) SetQueuedTime(queuedTime time.Time)

type Scheduler

+ func (s *Scheduler) AccessManaCache() *schedulerutils.AccessManaCache

+ func (s *Scheduler) BufferSize() int

+ func (s *Scheduler) GetManaFromCache(nodeID identity.ID) float64

+ func (s *Scheduler) MaxBufferSize() int

+ func (s *Scheduler) ReadyMessagesCount() int

+ func (s *Scheduler) TotalMessagesCount() int

type SchedulerEvents

+ MessageSkipped *events.Event

type SchedulerParams

+ AccessManaMapRetrieverFunc func() map[identity.ID]float64

+ ConfirmedMessageScheduleThreshold time.Duration

type Tangle

+ Dispatcher *Dispatcher

v0.8.3

Nov 30, 2021

v0.8.2

Nov 26, 2021

v0.8.1

Nov 11, 2021

Changes in this version

+ var DefaultRequesterOptions = &RequesterOptions

type Requester

+ func (r *Requester) Shutdown()

+ type RequesterEvents struct

+ RequestFailed *events.Event

+ RequestIssued *events.Event

+ RequestStarted *events.Event

+ RequestStopped *events.Event

type RequesterOption

+ func MaxRequestThreshold(maxRequestThreshold int) RequesterOption

+ func RetryJitter(retryJitter time.Duration) RequesterOption

type RequesterOptions

+ MaxRequestThreshold int

+ RetryInterval time.Duration

+ RetryJitter time.Duration

+ func (r RequesterOptions) Apply(optionalOptions ...RequesterOption) (updatedOptions RequesterOptions)

type Solidifier

+ func (s *Solidifier) RetrieveMissingMessage(messageID MessageID) (messageWasMissing bool)

v0.8.0

Nov 5, 2021

Changes in this version

+ const MaxParentsBlocksCount

+ const MinParentsBlocksCount

+ var ErrBlockTypeIsUnknown = errors.Errorf("block types must range from %d-%d", 0, NumberOfBlockTypes - 1)

+ var ErrBlocksNotOrderedByType = errors.New("blocks should be ordered in ascending order according to their type")

+ var ErrNoStrongParents = errors.New("missing strong messages in first parent block")

+ var ErrParentsNotLexicographicallyOrdered = errors.New("messages within blocks must be lexicographically ordered")

+ var ErrParentsOutOfRange = errors.Errorf("a block must have at least %d-%d parents", MinParentsCount, MaxParentsCount)

+ var ErrRepeatingBlockTypes = errors.New("block types within a message must not repeat")

+ var ErrRepeatingMessagesAcrossBlocks = errors.New("different blocks have repeating messages")

+ var ErrRepeatingReferencesInBlock = errors.New("duplicate parents in a message block")

+ func IssueAndValidateMessageApproval(t *testing.T, messageAlias string, eventMock *EventMock, ...)

+ type ActivityLog struct

+ func NewActivityLog() *ActivityLog

+ func (a *ActivityLog) Active(lowerBound, upperBound time.Time) (active, empty bool)

+ func (a *ActivityLog) Add(t time.Time) (added bool)

+ func (a *ActivityLog) Bytes() (marshaledBranchWeight []byte)

+ func (a *ActivityLog) Clone() *ActivityLog

+ func (a *ActivityLog) String() string

+ func (a *ActivityLog) Times() (times []int64)

type ApprovalWeightManager

+ func (a *ApprovalWeightManager) SupportersOfAggregatedBranch(branchID ledgerstate.BranchID) (supporters *Supporters)

+ func (a *ApprovalWeightManager) SupportersOfConflictBranch(branchID ledgerstate.BranchID) (supporters *Supporters)

type ApprovalWeightManagerEvents

+ BranchWeightChanged *events.Event

+ MarkerWeightChanged *events.Event

type BranchSupporters

+ func (b *BranchSupporters) AddSupporters(supporters *Supporters) (added bool)

+ type BranchWeightChangedEvent struct

+ BranchID ledgerstate.BranchID

+ Weight float64

+ type ConfirmationEvents struct

+ BranchConfirmed *events.Event

+ MessageConfirmed *events.Event

+ TransactionConfirmed *events.Event

+ type ConfirmationOracle interface

+ Events func() *ConfirmationEvents

+ IsBranchConfirmed func(branchID ledgerstate.BranchID) bool

+ IsMarkerConfirmed func(marker *markers.Marker) bool

+ IsMessageConfirmed func(msgID MessageID) bool

+ IsOutputConfirmed func(outputID ledgerstate.OutputID) bool

+ IsTransactionConfirmed func(transactionID ledgerstate.TransactionID) bool

+ type EventMock struct

+ func NewEventMock(t *testing.T, approvalWeightManager *ApprovalWeightManager) *EventMock

+ func (e *EventMock) AssertExpectations(t mock.TestingT) bool

+ func (e *EventMock) BranchWeightChanged(event *BranchWeightChangedEvent)

+ func (e *EventMock) DetachAll()

+ func (e *EventMock) Expect(eventName string, arguments ...interface{})

+ func (e *EventMock) MarkerWeightChanged(event *MarkerWeightChangedEvent)

+ func (e *EventMock) MessageProcessed(messageID MessageID)

type LedgerState

+ func (l *LedgerState) CachedTransactionMetadata(transactionID ledgerstate.TransactionID) *ledgerstate.CachedTransactionMetadata

+ func (l *LedgerState) ConfirmedConsumer(outputID ledgerstate.OutputID) (consumerID ledgerstate.TransactionID)

+ type LikeReferencesFunc func(parents MessageIDs, issuingTime time.Time, tangle *Tangle) (MessageIDs, error)

+ type MarkerConfirmed func(marker *markers.Marker) (confirmed bool)

type MarkerIndexBranchIDMapping

+ func (m *MarkerIndexBranchIDMapping) DeleteBranchID(index markers.Index)

+ type MarkerWeightChangedEvent struct

+ Marker *markers.Marker

+ Weight float64

type MarkersManager

+ func (m *MarkersManager) ForEachBranchIDMapping(sequenceID markers.SequenceID, thresholdIndex markers.Index, ...)

+ func (m *MarkersManager) ForEachMarkerReferencingMarker(referencedMarker *markers.Marker, ...)

+ func (m *MarkersManager) ForEachMessageApprovingMarker(marker *markers.Marker, callback func(approvingMessageID MessageID))

type Message

+ func (m *Message) ForEachParentByType(parentType ParentsType, consumer func(parentMessageID MessageID))

+ func (m *Message) ParentsByType(parentType ParentsType) MessageIDs

+ func (m *Message) ParentsCountByType(parentType ParentsType) uint8

type MessageID

+ func ReferenceFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (MessageID, error)

+ func (id MessageID) CompareTo(other MessageID) int

type MessageIDs

+ func PrepareLikeReferences(parents MessageIDs, issuingTime time.Time, tangle *Tangle) (MessageIDs, error)

type MessageMetadata

+ func (m *MessageMetadata) GradeOfFinality() (result gof.GradeOfFinality)

+ func (m *MessageMetadata) GradeOfFinalityTime() time.Time

+ func (m *MessageMetadata) SetGradeOfFinality(gradeOfFinality gof.GradeOfFinality) (modified bool)

type MessageOption

+ func WithIssuingTime(issuingTime time.Time) MessageOption

+ func WithLikeParents(messageAliases ...string) MessageOption

+ func WithReattachment(messageAlias string) MessageOption

type MessageTestFramework

+ func (m *MessageTestFramework) Branch(messageAlias string) (b ledgerstate.Branch)

+ func (m *MessageTestFramework) BranchIDFromMessage(messageAlias string) ledgerstate.BranchID

+ func (m *MessageTestFramework) OutputMetadata(outputID ledgerstate.OutputID) (outMeta *ledgerstate.OutputMetadata)

+ func (m *MessageTestFramework) RegisterBranchID(alias string, messageAliases ...string)

+ func (m *MessageTestFramework) Transaction(messageAlias string) (tx *ledgerstate.Transaction)

+ func (m *MessageTestFramework) TransactionMetadata(messageAlias string) (txMeta *ledgerstate.TransactionMetadata)

+ type MockConfirmationOracle struct

+ func (m *MockConfirmationOracle) Events() *ConfirmationEvents

+ func (m *MockConfirmationOracle) IsBranchConfirmed(branchID ledgerstate.BranchID) bool

+ func (m *MockConfirmationOracle) IsMarkerConfirmed(*markers.Marker) bool

+ func (m *MockConfirmationOracle) IsMessageConfirmed(msgID MessageID) bool

+ func (m *MockConfirmationOracle) IsOutputConfirmed(outputID ledgerstate.OutputID) bool

+ func (m *MockConfirmationOracle) IsTransactionConfirmed(transactionID ledgerstate.TransactionID) bool

+ type MockWeightProvider struct

+ func (m *MockWeightProvider) Shutdown()

+ func (m *MockWeightProvider) Update(t time.Time, nodeID identity.ID)

+ func (m *MockWeightProvider) Weight(message *Message) (weight, totalWeight float64)

+ func (m *MockWeightProvider) WeightsOfRelevantSupporters() (weights map[identity.ID]float64, totalWeight float64)

+ type NodeIdentities map[string]*identity.Identity

+ type OTVConsensusManager struct

+ func NewOTVConsensusManager(otvConsensusMechanism consensus.Mechanism) *OTVConsensusManager

+ type ParentsBlock struct

+ References MessageIDs

+ type ParentsType uint8

+ const DislikeParentType

+ const LikeParentType

+ const NumberOfBlockTypes

+ const NumberOfUniqueBlocks

+ const StrongParentType

+ const WeakParentType

+ func (bp ParentsType) String() string

+ type PrePostStepTuple struct

+ Post TestStep

+ Pre TestStep

+ type SimpleMockOnTangleVoting struct

+ func (o *SimpleMockOnTangleVoting) LikedInstead(branchID ledgerstate.BranchID) (opinionTuple []consensus.OpinionTuple, err error)

+ func (o *SimpleMockOnTangleVoting) Opinion(branchIDs ledgerstate.BranchIDs) (liked, disliked ledgerstate.BranchIDs, err error)

type Tangle

+ ConfirmationOracle ConfirmationOracle

+ OTVConsensusManager *OTVConsensusManager

+ func NewTestTangle(options ...Option) *Tangle

+ type TestScenario struct

+ PostStep TestStep

+ Steps []TestStep

+ Tangle *Tangle

+ func ProcessMessageScenario(t *testing.T) *TestScenario

+ func (s *TestScenario) Cleanup(t *testing.T) error

+ func (s *TestScenario) HasNext() bool

+ func (s *TestScenario) Next(prePostStepTuple *PrePostStepTuple)

+ func (s *TestScenario) Setup(t *testing.T) error

+ type TestStep func(t *testing.T, testFramework *MessageTestFramework, testEventMock *EventMock, ...)

type TipManager

+ func (t *TipManager) AllTips() MessageIDs

type Utils

+ func (u *Utils) FirstAttachment(transactionID ledgerstate.TransactionID) (oldestAttachmentTime time.Time, oldestAttachmentMessageID MessageID, err error)

v0.7.7

Oct 9, 2021

v0.7.6

Sep 23, 2021

Changes in this version

+ var ErrParentsInvalid = errors.New("one or more parents is invalid")

+ func MessageInvalidCaller(handler interface{}, params ...interface{})

+ type MessageInvalidEvent struct

+ Error error

+ MessageID MessageID

type MessageSignatureFilter

+ func (f *MessageSignatureFilter) Close() error

type Parser

+ func (p *Parser) Shutdown()

+ type TimestampFilter struct

+ func NewTimestampFilter() *TimestampFilter

+ func (f *TimestampFilter) Close() error

+ func (f *TimestampFilter) Filter(msg *Message, p *peer.Peer)

+ func (f *TimestampFilter) OnAccept(callback func(msg *Message, p *peer.Peer))

+ func (f *TimestampFilter) OnReject(callback func(msg *Message, err error, p *peer.Peer))

type TransactionFilter

+ func (f *TransactionFilter) Close() error

v0.7.5

Aug 9, 2021

Changes in this version

type MessageMetadata

+ func (m *MessageMetadata) ScheduledBypass() (result bool)

+ func (m *MessageMetadata) SetScheduledBypass(scheduledBypass bool) (modified bool)

type SchedulerEvents

+ Error *events.Event

v0.7.4

Jul 8, 2021

v0.7.3

Jul 1, 2021

Changes in this version

+ const DefaultSyncTimeWindow

type Option

+ func CacheTimeProvider(cacheTimeProvider *database.CacheTimeProvider) Option

type Options

+ CacheTimeProvider *database.CacheTimeProvider

type TimeManager

+ func (t *TimeManager) Start()

v0.7.2

Jun 17, 2021

v0.7.1

Jun 15, 2021

v0.7.0

Jun 2, 2021

v0.6.4

May 29, 2021

v0.6.3

May 25, 2021

Changes in this version

type ApprovalWeightManagerEvents

+ MessageFinalized *events.Event

v0.6.2

May 24, 2021

Changes in this version

+ const Backoff

+ const MaxDeficit

+ const MaxLocalQueueSize

+ const MinMana

+ const RateSettingDecrease

+ const RateSettingIncrease

+ const RateSettingPause

+ var ErrInvalidIssuer = errors.New("message not issued by local node")

+ var ErrNotRunning = errors.New("scheduler stopped")

+ var ErrStopped = errors.New("rate setter stopped")

+ var Initial = 20000.0

+ func NodeIDCaller(handler interface{}, params ...interface{})

+ type FIFOScheduler struct

+ Events *FIFOSchedulerEvents

+ func NewFIFOScheduler(tangle *Tangle) *FIFOScheduler

+ func (s *FIFOScheduler) Schedule(messageID MessageID)

+ func (s *FIFOScheduler) Setup()

+ func (s *FIFOScheduler) Shutdown()

+ func (s *FIFOScheduler) Start()

+ type FIFOSchedulerEvents struct

+ MessageDiscarded *events.Event

+ MessageScheduled *events.Event

+ NodeBlacklisted *events.Event

type LedgerState

+ func (l *LedgerState) CachedOutput(outputID ledgerstate.OutputID) *ledgerstate.CachedOutput

+ func (l *LedgerState) CachedOutputMetadata(outputID ledgerstate.OutputID) *ledgerstate.CachedOutputMetadata

+ func (l *LedgerState) CachedOutputsOnAddress(address ledgerstate.Address) (cachedOutputs ledgerstate.CachedOutputs)

+ func (l *LedgerState) ReturnTransaction(transactionID ledgerstate.TransactionID) (transaction *ledgerstate.Transaction)

+ func (l *LedgerState) SnapshotUTXO() (snapshot *ledgerstate.Snapshot)

+ func (l *LedgerState) Transactions() (transactions map[ledgerstate.TransactionID]*ledgerstate.Transaction)

type Message

+ func (m *Message) IDBytes() []byte

+ func (m *Message) Size() int

type MessageFactory

+ func (f *MessageFactory) SetTimeout(timeout time.Duration)

type Option

+ func RateSetterConfig(params RateSetterParams) Option

+ func SchedulerConfig(config SchedulerParams) Option

type Options

+ RateSetterParams RateSetterParams

+ SchedulerParams SchedulerParams

+ type Orderer struct

+ Events *OrdererEvents

+ func NewOrderer(tangle *Tangle) (orderer *Orderer)

+ func (o *Orderer) Setup()

+ func (o *Orderer) Shutdown()

+ type OrdererEvents struct

+ MessageOrdered *events.Event

+ type RateSetter struct

+ Events *RateSetterEvents

+ func NewRateSetter(tangle *Tangle) *RateSetter

+ func (r *RateSetter) Issue(message *Message) error

+ func (r *RateSetter) Rate() float64

+ func (r *RateSetter) Setup()

+ func (r *RateSetter) Shutdown()

+ func (r *RateSetter) Size() int

+ type RateSetterEvents struct

+ MessageDiscarded *events.Event

+ type RateSetterParams struct

+ Initial *float64

type Scheduler

+ func (s *Scheduler) Clear()

+ func (s *Scheduler) NodeQueueSize(nodeID identity.ID) int

+ func (s *Scheduler) NodeQueueSizes() map[identity.ID]int

+ func (s *Scheduler) Rate() time.Duration

+ func (s *Scheduler) Ready(messageID MessageID) (err error)

+ func (s *Scheduler) Running() bool

+ func (s *Scheduler) SetRate(rate time.Duration)

+ func (s *Scheduler) Start()

+ func (s *Scheduler) Submit(messageID MessageID) (err error)

+ func (s *Scheduler) SubmitAndReady(messageID MessageID) error

+ func (s *Scheduler) Unsubmit(messageID MessageID) (err error)

type SchedulerEvents

+ MessageDiscarded *events.Event

+ NodeBlacklisted *events.Event

+ type SchedulerParams struct

+ AccessManaRetrieveFunc func(identity.ID) float64

+ MaxBufferSize int

+ Rate time.Duration

+ TotalAccessManaRetrieveFunc func() float64

type Tangle

+ FIFOScheduler *FIFOScheduler

+ Orderer *Orderer

+ RateSetter *RateSetter

v0.6.1

May 19, 2021

v0.6.0

May 19, 2021

Changes in this version

+ func MessageCaller(handler interface{}, params ...interface{})

+ func SyncChangedCaller(handler interface{}, params ...interface{})

type ConsensusManagerEvents

+ StatementProcessed *events.Event

type LedgerState

+ func (l *LedgerState) TotalSupply() (totalSupply uint64)

+ type SyncChangedEvent struct

+ Synced bool

type TimeManager

+ Events *TimeManagerEvents

+ type TimeManagerEvents struct

+ SyncChanged *events.Event

v0.5.9

May 11, 2021

Changes in this version

type Option

+ func StartSynced(startSynced bool) Option

type Options

+ StartSynced bool

v0.5.8

May 7, 2021

Changes in this version

+ const DefaultGenesisTime

+ type CManaWeightProvider struct

+ func NewCManaWeightProvider(manaRetrieverFunc ManaRetrieverFunc, timeRetrieverFunc TimeRetrieverFunc, ...) (cManaWeightProvider *CManaWeightProvider)

+ func (c *CManaWeightProvider) ActiveNodes() (activeNodes map[identity.ID]time.Time)

+ func (c *CManaWeightProvider) Shutdown()

+ func (c *CManaWeightProvider) Update(t time.Time, nodeID identity.ID)

+ func (c *CManaWeightProvider) Weight(message *Message) (weight, totalWeight float64)

+ func (c *CManaWeightProvider) WeightsOfRelevantSupporters() (weights map[identity.ID]float64, totalWeight float64)

type ConsensusManager

+ func (o *ConsensusManager) SetTransactionLiked(transactionID ledgerstate.TransactionID, liked bool) (modified bool)

type ConsensusMechanism

+ SetTransactionLiked func(transactionID ledgerstate.TransactionID, liked bool) (modified bool)

+ type LastConfirmedMessage struct

+ MessageID MessageID

+ Time time.Time

+ func (l LastConfirmedMessage) Bytes() (marshaledLastConfirmedMessage []byte)

+ func (l LastConfirmedMessage) String() string

type LedgerState

+ UTXODAG *ledgerstate.UTXODAG

+ type ManaRetrieverFunc func() map[identity.ID]float64

type MessageMetadata

+ func (m *MessageMetadata) FinalizedTime() time.Time

+ func (m *MessageMetadata) IsFinalized() (result bool)

+ func (m *MessageMetadata) SetFinalized(finalized bool) (modified bool)

type Option

+ func SyncTimeWindow(syncTimeWindow time.Duration) Option

type Options

+ SyncTimeWindow time.Duration

type Tangle

+ TimeManager *TimeManager

+ type TimeManager struct

+ func NewTimeManager(tangle *Tangle) (timeManager *TimeManager)

+ func (t *TimeManager) LastConfirmedMessage() LastConfirmedMessage

+ func (t *TimeManager) Setup()

+ func (t *TimeManager) Shutdown()

+ func (t *TimeManager) Synced() bool

+ func (t *TimeManager) Time() time.Time

+ type TimeRetrieverFunc func() time.Time

type WeightProvider

+ Shutdown func()

+ Update func(t time.Time, nodeID identity.ID)

v0.5.7

Apr 23, 2021

Changes in this version

+ const PrefixBranchSupporters

+ const PrefixBranchWeight

+ const PrefixIndividuallyMappedMessage

+ const PrefixMarkerMessageMapping

+ const PrefixSequenceSupporters

+ const PrefixStatement

+ var CacheTime = 2 * time.Second

+ var IndividuallyMappedMessagePartitionKeys = objectstorage.PartitionKey([]int{ ... })

+ var MarkerMessageMappingPartitionKeys = objectstorage.PartitionKey(markers.SequenceIDLength, markers.IndexLength)

+ func BranchSupportersFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func BranchWeightFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func IndividuallyMappedMessageFromObjectStorage(key, value []byte) (result objectstorage.StorableObject, err error)

+ func MarkerMessageMappingFromObjectStorage(key, value []byte) (result objectstorage.StorableObject, err error)

+ func RegisterMessageIDAlias(messageID MessageID, alias string)

+ func SequenceSupportersFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func StatementFromObjectStorage(key, data []byte) (result objectstorage.StorableObject, err error)

+ func UnregisterMessageIDAliases()

+ type ApprovalWeightManager struct

+ Events *ApprovalWeightManagerEvents

+ func NewApprovalWeightManager(tangle *Tangle) (approvalWeightManager *ApprovalWeightManager)

+ func (a *ApprovalWeightManager) ProcessMessage(messageID MessageID)

+ func (a *ApprovalWeightManager) Setup()

+ func (a *ApprovalWeightManager) Shutdown()

+ func (a *ApprovalWeightManager) WeightOfBranch(branchID ledgerstate.BranchID) (weight float64)

+ func (a *ApprovalWeightManager) WeightOfMarker(marker *markers.Marker, anchorTime time.Time) (weight float64)

+ type ApprovalWeightManagerEvents struct

+ BranchConfirmation *events.ThresholdEvent

+ MarkerConfirmation *events.ThresholdEvent

+ MessageProcessed *events.Event

type Booker

+ func (b *Booker) BookConflictingTransaction(transactionID ledgerstate.TransactionID) (err error)

+ func (b *Booker) BookMessage(messageID MessageID) (err error)

+ func (b *Booker) MessageBranchID(messageID MessageID) (branchID ledgerstate.BranchID, err error)

type BookerEvents

+ Error *events.Event

+ MarkerBranchUpdated *events.Event

+ MessageBranchUpdated *events.Event

+ type BranchSupporters struct

+ func BranchSupportersFromBytes(bytes []byte) (branchSupporters *BranchSupporters, consumedBytes int, err error)

+ func BranchSupportersFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (branchSupporters *BranchSupporters, err error)

+ func NewBranchSupporters(branchID ledgerstate.BranchID) (branchSupporters *BranchSupporters)

+ func (b *BranchSupporters) AddSupporter(supporter Supporter) (added bool)

+ func (b *BranchSupporters) BranchID() (branchID ledgerstate.BranchID)

+ func (b *BranchSupporters) Bytes() (marshaledBranchSupporters []byte)

+ func (b *BranchSupporters) DeleteSupporter(supporter Supporter) (deleted bool)

+ func (b *BranchSupporters) ObjectStorageKey() []byte

+ func (b *BranchSupporters) ObjectStorageValue() []byte

+ func (b *BranchSupporters) String() string

+ func (b *BranchSupporters) Supporters() (supporters *Supporters)

+ func (b *BranchSupporters) Update(objectstorage.StorableObject)

+ type BranchWeight struct

+ func BranchWeightFromBytes(bytes []byte) (branchWeight *BranchWeight, consumedBytes int, err error)

+ func BranchWeightFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (branchWeight *BranchWeight, err error)

+ func NewBranchWeight(branchID ledgerstate.BranchID) (branchWeight *BranchWeight)

+ func (b *BranchWeight) BranchID() (branchID ledgerstate.BranchID)

+ func (b *BranchWeight) Bytes() (marshaledBranchWeight []byte)

+ func (b *BranchWeight) DecreaseWeight(weight float64) (newWeight float64)

+ func (b *BranchWeight) IncreaseWeight(weight float64) (newWeight float64)

+ func (b *BranchWeight) ObjectStorageKey() []byte

+ func (b *BranchWeight) ObjectStorageValue() []byte

+ func (b *BranchWeight) SetWeight(weight float64) (modified bool)

+ func (b *BranchWeight) String() string

+ func (b *BranchWeight) Update(objectstorage.StorableObject)

+ func (b *BranchWeight) Weight() (weight float64)

+ type CachedBranchSupporters struct

+ func (c *CachedBranchSupporters) Consume(consumer func(branchSupporters *BranchSupporters), forceRelease ...bool) (consumed bool)

+ func (c *CachedBranchSupporters) Retain() *CachedBranchSupporters

+ func (c *CachedBranchSupporters) String() string

+ func (c *CachedBranchSupporters) Unwrap() *BranchSupporters

+ type CachedBranchWeight struct

+ func (c *CachedBranchWeight) Consume(consumer func(branchWeight *BranchWeight), forceRelease ...bool) (consumed bool)

+ func (c *CachedBranchWeight) Retain() *CachedBranchWeight

+ func (c *CachedBranchWeight) String() string

+ func (c *CachedBranchWeight) Unwrap() *BranchWeight

+ type CachedIndividuallyMappedMessage struct

+ func (c *CachedIndividuallyMappedMessage) Consume(consumer func(individuallyMappedMessage *IndividuallyMappedMessage), ...) (consumed bool)

+ func (c *CachedIndividuallyMappedMessage) Retain() *CachedIndividuallyMappedMessage

+ func (c *CachedIndividuallyMappedMessage) String() string

+ func (c *CachedIndividuallyMappedMessage) Unwrap() *IndividuallyMappedMessage

+ type CachedIndividuallyMappedMessages []*CachedIndividuallyMappedMessage

+ func (c CachedIndividuallyMappedMessages) Consume(consumer func(individuallyMappedMessage *IndividuallyMappedMessage), ...) (consumed bool)

+ func (c CachedIndividuallyMappedMessages) Release(force ...bool)

+ func (c CachedIndividuallyMappedMessages) String() string

+ func (c CachedIndividuallyMappedMessages) Unwrap() (unwrappedIndividuallyMappedMessages []*IndividuallyMappedMessage)

+ type CachedMarkerMessageMapping struct

+ func (c *CachedMarkerMessageMapping) Consume(consumer func(markerMessageMapping *MarkerMessageMapping), ...) (consumed bool)

+ func (c *CachedMarkerMessageMapping) Retain() *CachedMarkerMessageMapping

+ func (c *CachedMarkerMessageMapping) String() string

+ func (c *CachedMarkerMessageMapping) Unwrap() *MarkerMessageMapping

+ type CachedMarkerMessageMappings []*CachedMarkerMessageMapping

+ func (c CachedMarkerMessageMappings) Consume(consumer func(markerMessageMapping *MarkerMessageMapping), ...) (consumed bool)

+ func (c CachedMarkerMessageMappings) Release(force ...bool)

+ func (c CachedMarkerMessageMappings) String() string

+ func (c CachedMarkerMessageMappings) Unwrap() (unwrappedMarkerMessageMappings []*MarkerMessageMapping)

+ type CachedSequenceSupporters struct

+ func (c *CachedSequenceSupporters) Consume(consumer func(sequenceSupporters *SequenceSupporters), forceRelease ...bool) (consumed bool)

+ func (c *CachedSequenceSupporters) Retain() *CachedSequenceSupporters

+ func (c *CachedSequenceSupporters) String() string

+ func (c *CachedSequenceSupporters) Unwrap() *SequenceSupporters

+ type CachedStatement struct

+ func (c *CachedStatement) Consume(consumer func(statement *Statement), forceRelease ...bool) (consumed bool)

+ func (c *CachedStatement) Retain() *CachedStatement

+ func (c *CachedStatement) String() string

+ func (c *CachedStatement) Unwrap() *Statement

+ type Epoch = uint64

+ type IndividuallyMappedMessage struct

+ func IndividuallyMappedMessageFromBytes(bytes []byte) (individuallyMappedMessage *IndividuallyMappedMessage, consumedBytes int, ...)

+ func IndividuallyMappedMessageFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (individuallyMappedMessage *IndividuallyMappedMessage, err error)

+ func NewIndividuallyMappedMessage(branchID ledgerstate.BranchID, messageID MessageID, ...) *IndividuallyMappedMessage

+ func (i *IndividuallyMappedMessage) BranchID() ledgerstate.BranchID

+ func (i *IndividuallyMappedMessage) Bytes() []byte

+ func (i *IndividuallyMappedMessage) MessageID() MessageID

+ func (i *IndividuallyMappedMessage) ObjectStorageKey() []byte

+ func (i *IndividuallyMappedMessage) ObjectStorageValue() []byte

+ func (i *IndividuallyMappedMessage) PastMarkers() *markers.Markers

+ func (i *IndividuallyMappedMessage) String() string

+ func (i *IndividuallyMappedMessage) Update(objectstorage.StorableObject)

type MarkerIndexBranchIDMapping

+ func (m *MarkerIndexBranchIDMapping) Ceiling(index markers.Index) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ func (m *MarkerIndexBranchIDMapping) Floor(index markers.Index) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ type MarkerMessageMapping struct

+ func MarkerMessageMappingFromBytes(bytes []byte) (individuallyMappedMessage *MarkerMessageMapping, consumedBytes int, err error)

+ func MarkerMessageMappingFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (markerMessageMapping *MarkerMessageMapping, err error)

+ func NewMarkerMessageMapping(marker *markers.Marker, messageID MessageID) *MarkerMessageMapping

+ func (m *MarkerMessageMapping) Bytes() []byte

+ func (m *MarkerMessageMapping) Marker() *markers.Marker

+ func (m *MarkerMessageMapping) MessageID() MessageID

+ func (m *MarkerMessageMapping) ObjectStorageKey() []byte

+ func (m *MarkerMessageMapping) ObjectStorageValue() []byte

+ func (m *MarkerMessageMapping) String() string

+ func (m *MarkerMessageMapping) Update(objectstorage.StorableObject)

type MarkersManager

+ func (m *MarkersManager) BranchID(marker *markers.Marker) (branchID ledgerstate.BranchID)

+ func (m *MarkersManager) BranchMappedByPastMarkers(branch ledgerstate.BranchID, pastMarkers *markers.Markers) (branchMappedByPastMarkers bool)

+ func (m *MarkersManager) Ceiling(referenceMarker *markers.Marker) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ func (m *MarkersManager) Floor(referenceMarker *markers.Marker) (marker markers.Index, branchID ledgerstate.BranchID, exists bool)

+ func (m *MarkersManager) MessageID(marker *markers.Marker) (messageID MessageID)

+ func (m *MarkersManager) SetBranchID(marker *markers.Marker, branchID ledgerstate.BranchID) (updated bool)

+ func (m *MarkersManager) SetMessageID(marker *markers.Marker, messageID MessageID)

type MessageID

+ func (id MessageID) Base58() string

type MessageMetadata

+ func (m *MessageMetadata) IsFinalizedApprovalWeight() (result bool)

+ func (m *MessageMetadata) SetFinalizedApprovalWeight(finalized bool) (modified bool)

type MessageOption

+ func WithIssuer(issuer ed25519.PublicKey) MessageOption

type MessageTestFramework

+ func (m *MessageTestFramework) BranchID(messageAlias string) ledgerstate.BranchID

+ func (m *MessageTestFramework) IncreaseMarkersIndexCallback(markers.SequenceID, markers.Index) bool

+ func (m *MessageTestFramework) MessageMetadata(alias string) (messageMetadata *MessageMetadata)

+ func (m *MessageTestFramework) PreventNewMarkers(enabled bool) *MessageTestFramework

+ func (m *MessageTestFramework) TransactionID(messageAlias string) ledgerstate.TransactionID

+ func (m *MessageTestFramework) WaitApprovalWeightProcessed() *MessageTestFramework

type Option

+ func ApprovalWeights(weightProvider WeightProvider) Option

type Options

+ WeightProvider WeightProvider

+ type SequenceSupporters struct

+ func NewSequenceSupporters(sequenceID markers.SequenceID) (sequenceSupporters *SequenceSupporters)

+ func SequenceSupportersFromBytes(bytes []byte) (sequenceSupporters *SequenceSupporters, consumedBytes int, err error)

+ func SequenceSupportersFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (sequenceSupporters *SequenceSupporters, err error)

+ func (s *SequenceSupporters) AddSupporter(supporter Supporter, index markers.Index) (added bool)

+ func (s *SequenceSupporters) Bytes() (marshaledSequenceSupporters []byte)

+ func (s *SequenceSupporters) ObjectStorageKey() []byte

+ func (s *SequenceSupporters) ObjectStorageValue() []byte

+ func (s *SequenceSupporters) SequenceID() (sequenceID markers.SequenceID)

+ func (s *SequenceSupporters) String() string

+ func (s *SequenceSupporters) Supporters(index markers.Index) (supporters *Supporters)

+ func (s *SequenceSupporters) Update(objectstorage.StorableObject)

+ type Statement struct

+ func NewStatement(branchID ledgerstate.BranchID, supporter Supporter) (statement *Statement)

+ func StatementFromBytes(bytes []byte) (statement *Statement, consumedBytes int, err error)

+ func StatementFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (statement *Statement, err error)

+ func (s *Statement) BranchID() (branchID ledgerstate.BranchID)

+ func (s *Statement) Bytes() (marshaledSequenceSupporters []byte)

+ func (s *Statement) ObjectStorageKey() []byte

+ func (s *Statement) ObjectStorageValue() []byte

+ func (s *Statement) SequenceNumber() (sequenceNumber uint64)

+ func (s *Statement) String() string

+ func (s *Statement) Supporter() (supporter Supporter)

+ func (s *Statement) Update(objectstorage.StorableObject)

+ func (s *Statement) UpdateSequenceNumber(sequenceNumber uint64) (updated bool)

type Storage

+ func (s *Storage) BranchSupporters(branchID ledgerstate.BranchID, ...) *CachedBranchSupporters

+ func (s *Storage) BranchWeight(branchID ledgerstate.BranchID, ...) *CachedBranchWeight

+ func (s *Storage) DeleteIndividuallyMappedMessage(branchID ledgerstate.BranchID, messageID MessageID)

+ func (s *Storage) DeleteMarkerMessageMapping(branchID ledgerstate.BranchID, messageID MessageID)

+ func (s *Storage) IndividuallyMappedMessage(branchID ledgerstate.BranchID, messageID MessageID) (cachedIndividuallyMappedMessages *CachedIndividuallyMappedMessage)

+ func (s *Storage) IndividuallyMappedMessages(branchID ledgerstate.BranchID) (cachedIndividuallyMappedMessages CachedIndividuallyMappedMessages)

+ func (s *Storage) MarkerMessageMapping(marker *markers.Marker) (cachedMarkerMessageMappings *CachedMarkerMessageMapping)

+ func (s *Storage) MarkerMessageMappings(sequenceID markers.SequenceID) (cachedMarkerMessageMappings CachedMarkerMessageMappings)

+ func (s *Storage) SequenceSupporters(sequenceID markers.SequenceID, ...) *CachedSequenceSupporters

+ func (s *Storage) Statement(branchID ledgerstate.BranchID, supporter Supporter, ...) *CachedStatement

+ func (s *Storage) StoreIndividuallyMappedMessage(individuallyMappedMessage *IndividuallyMappedMessage)

+ func (s *Storage) StoreMarkerMessageMapping(markerMessageMapping *MarkerMessageMapping)

+ type Supporter = identity.ID

+ type Supporters struct

+ func NewSupporters() (supporters *Supporters)

+ func (s *Supporters) Add(supporter Supporter) (added bool)

+ func (s *Supporters) Clone() (clonedSupporters *Supporters)

+ func (s *Supporters) Delete(supporter Supporter) (deleted bool)

+ func (s *Supporters) ForEach(callback func(supporter Supporter))

+ func (s *Supporters) Has(supporter Supporter) (has bool)

+ func (s *Supporters) Intersect(other *Supporters) (intersection *Supporters)

+ func (s *Supporters) String() string

type Tangle

+ ApprovalWeightManager *ApprovalWeightManager

+ WeightProvider WeightProvider

+ type WeightProvider interface

+ Epoch func(referenceTime time.Time) Epoch

+ Weight func(epoch Epoch, message *Message) (weight, totalWeight float64)

+ WeightsOfRelevantSupporters func(epoch Epoch) (weights map[identity.ID]float64, totalWeight float64)

+ func WeightProviderFromEpochsManager(epochManager *epochs.Manager) WeightProvider

v0.5.6

Apr 3, 2021

v0.5.5

Apr 1, 2021

v0.5.4

Mar 29, 2021

Changes in this version

+ var ErrInvalidInputs = errors.New("one or more inputs are rejected or non-monotonically liked")

type TipManager

+ func (t *TipManager) AllStrongTips() MessageIDs

+ func (t *TipManager) AllWeakTips() MessageIDs

v0.5.3

Mar 25, 2021

Changes in this version

type LedgerState

+ BranchDAG *ledgerstate.BranchDAG

+ func (l *LedgerState) Consumers(outputID ledgerstate.OutputID) (cachedTransactions ledgerstate.CachedConsumers)

type MessageMetadata

+ func (m *MessageMetadata) BookedTime() time.Time

+ func (m *MessageMetadata) ScheduledTime() time.Time

+ type MessageOption func(*MessageTestFrameworkMessageOptions)

+ func WithColoredOutput(alias string, balances map[ledgerstate.Color]uint64) MessageOption

+ func WithInputs(inputAliases ...string) MessageOption

+ func WithOutput(alias string, balance uint64) MessageOption

+ func WithStrongParents(messageAliases ...string) MessageOption

+ func WithWeakParents(messageAliases ...string) MessageOption

+ type MessageTestFramework struct

+ func NewMessageTestFramework(tangle *Tangle, options ...MessageTestFrameworkOption) (messageTestFramework *MessageTestFramework)

+ func (m *MessageTestFramework) CreateMessage(messageAlias string, messageOptions ...MessageOption) (message *Message)

+ func (m *MessageTestFramework) IssueMessages(messageAliases ...string) *MessageTestFramework

+ func (m *MessageTestFramework) Message(alias string) (message *Message)

+ func (m *MessageTestFramework) WaitMessagesBooked()

+ type MessageTestFrameworkMessageOptions struct

+ func NewMessageTestFrameworkMessageOptions(options ...MessageOption) (messageOptions *MessageTestFrameworkMessageOptions)

+ type MessageTestFrameworkOption func(*MessageTestFrameworkOptions)

+ func WithColoredGenesisOutput(alias string, balances map[ledgerstate.Color]uint64) MessageTestFrameworkOption

+ func WithGenesisOutput(alias string, balance uint64) MessageTestFrameworkOption

+ type MessageTestFrameworkOptions struct

+ func NewMessageTestFrameworkOptions(options ...MessageTestFrameworkOption) (frameworkOptions *MessageTestFrameworkOptions)

v0.5.2

Mar 17, 2021

Changes in this version

type Option

+ func GenesisNode(genesisNodeBase58 string) Option

+ func Width(width int) Option

type Options

+ GenesisNode *ed25519.PublicKey

v0.5.1

Mar 15, 2021

Changes in this version

+ type TimedTaskExecutor struct

+ func NewTimedTaskExecutor(workerCount int) *TimedTaskExecutor

+ func (t *TimedTaskExecutor) Cancel(identifier interface{}) (canceled bool)

+ func (t *TimedTaskExecutor) ExecuteAfter(identifier interface{}, callback func(), delay time.Duration) *timedexecutor.ScheduledTask

+ func (t *TimedTaskExecutor) ExecuteAt(identifier interface{}, callback func(), executionTime time.Time) *timedexecutor.ScheduledTask

type TipManager

+ func (t *TipManager) Shutdown()

v0.5.0

Mar 11, 2021

Changes in this version

+ var ErrNotSynced = errors.New("tangle not synced")

+ func MessageIDCaller(handler interface{}, params ...interface{})

+ type ConsensusManager struct

+ Events *ConsensusManagerEvents

+ func NewConsensusManager(tangle *Tangle) (opinionFormer *ConsensusManager)

+ func (o *ConsensusManager) MessageEligible(messageID MessageID) (eligible bool)

+ func (o *ConsensusManager) PayloadLiked(messageID MessageID) (liked bool)

+ func (o *ConsensusManager) Setup()

+ func (o *ConsensusManager) Shutdown()

+ type ConsensusManagerEvents struct

+ MessageOpinionFormed *events.Event

+ TransactionConfirmed *events.Event

+ type ConsensusMechanism interface

+ Init func(tangle *Tangle)

+ Setup func()

+ Shutdown func()

+ TransactionLiked func(transactionID ledgerstate.TransactionID) (liked bool)

type LedgerState

+ func (l *LedgerState) SetBranchFinalized(branchID ledgerstate.BranchID, finalized bool) (modified bool, err error)

+ func (l *LedgerState) SetBranchLiked(branchID ledgerstate.BranchID, liked bool) (modified bool, err error)

type Option

+ func Consensus(consensusMechanism ConsensusMechanism) Option

type Options

+ ConsensusMechanism ConsensusMechanism

type Tangle

+ ConsensusManager *ConsensusManager

+ func (t *Tangle) Configure(options ...Option)

+ func (t *Tangle) IssuePayload(payload payload.Payload) (message *Message, err error)

+ func (t *Tangle) SetSynced(synced bool) (modified bool)

+ func (t *Tangle) Synced() (synced bool)

v0.4.1

Mar 2, 2021

Changes in this version

type LedgerState

+ func (l *LedgerState) ConsumedOutputs(transaction *ledgerstate.Transaction) (cachedInputs ledgerstate.CachedOutputs)

type Utils

+ func (u *Utils) AllTransactionsApprovedByMessages(transactionIDs ledgerstate.TransactionIDs, messageIDs ...MessageID) (approved bool)

v0.4.0

Feb 26, 2021

Changes in this version

type Booker

+ func (b *Booker) Setup()

+ func (b *Booker) UpdateMessagesBranch(transactionID ledgerstate.TransactionID)

type FCoB

+ func (f *FCoB) TransactionOpinionEssence(transactionID ledgerstate.TransactionID) (opinion OpinionEssence)

type LedgerState

+ func (l *LedgerState) Branch(branchID ledgerstate.BranchID) *ledgerstate.CachedBranch

+ func (l *LedgerState) CheckTransaction(transaction *ledgerstate.Transaction) (valid bool, err error)

+ func (l *LedgerState) Output(outputID ledgerstate.OutputID) *ledgerstate.CachedOutput

+ func (l *LedgerState) OutputMetadata(outputID ledgerstate.OutputID) *ledgerstate.CachedOutputMetadata

+ func (l *LedgerState) OutputsOnAddress(address ledgerstate.Address) (cachedOutputs ledgerstate.CachedOutputs)

+ func (l *LedgerState) Transaction(transactionID ledgerstate.TransactionID) *ledgerstate.CachedTransaction

type LevelOfKnowledge

+ func (l LevelOfKnowledge) String() string

type MessageMetadata

+ func (m *MessageMetadata) Scheduled() (result bool)

+ func (m *MessageMetadata) SetScheduled(scheduled bool) (modified bool)

+ func (m *MessageMetadata) String() string

type OpinionEssence

+ func (o OpinionEssence) LevelOfKnowledge() LevelOfKnowledge

+ func (o OpinionEssence) Liked() bool

+ func (o OpinionEssence) Timestamp() time.Time

type OpinionFormerEvents

+ TransactionConfirmed *events.Event

type OpinionVoterProvider

+ TransactionOpinionEssence func(ledgerstate.TransactionID) OpinionEssence

type Option

+ func IncreaseMarkersIndexCallback(callback markers.IncreaseIndexCallback) Option

+ func TangleWidth(width int) Option

type Options

+ IncreaseMarkersIndexCallback markers.IncreaseIndexCallback

+ TangleWidth int

type Scheduler

+ func (s *Scheduler) Schedule(messageID MessageID)

type Storage

+ func (s *Storage) IsTransactionAttachedByMessage(transactionID ledgerstate.TransactionID, messageID MessageID) (attached bool)

type TimestampOpinion

+ func (t TimestampOpinion) String() string

+ type TipEvent struct

+ MessageID MessageID

+ TipType TipType

type TipManager

+ func (t *TipManager) StrongTipCount() int

+ func (t *TipManager) WeakTipCount() int

+ type TipType uint8

+ const StrongTip

+ const WeakTip

+ func (t TipType) String() string

type Utils

+ func (u *Utils) AllTransactionsApprovedByMessage(transactionIDs ledgerstate.TransactionIDs, messageID MessageID) (approved bool)

+ func (u *Utils) AllTransactionsContainedOrApprovedByMessages(transactionIDs ledgerstate.TransactionIDs, messageIDs MessageIDs) (approved bool)

+ func (u *Utils) MessageApprovedByStrongParents(approvedMessageID MessageID, approvingMessageID MessageID) (approved bool)

+ func (u *Utils) TransactionApprovedByMessage(transactionID ledgerstate.TransactionID, messageID MessageID) (approved bool)

v0.3.6

Feb 12, 2021

Changes in this version

+ const ApproverTypeLength

+ const AttachmentLength

+ const MaxReattachmentTimeMin

+ const PrefixAttachments

+ const PrefixFCoB

+ const PrefixMarkerBranchIDMapping

+ const TimestampOpinionLength

+ var ErrInvalidMessageAndTransactionTimestamp = fmt.Errorf("invalid message and transaction timestamp")

+ var GratuitousNetworkDelay time.Duration

+ var LikedThreshold = 5 * time.Second

+ var LocallyFinalizedThreshold = 10 * time.Second

+ var TimestampWindow time.Duration

+ func AttachmentFromObjectStorage(key []byte, _ []byte) (result objectstorage.StorableObject, err error)

+ func MarkerIndexBranchIDMappingFromObjectStorage(key []byte, data []byte) (markerIndexBranchIDMapping objectstorage.StorableObject, err error)

+ func OpinionFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error)

type Approver

+ func (a *Approver) Type() ApproverType

+ type ApproverType uint8

+ const StrongApprover

+ const WeakApprover

+ func ApproverTypeFromBytes(bytes []byte) (approverType ApproverType, consumedBytes int, err error)

+ func ApproverTypeFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (approverType ApproverType, err error)

+ func (a ApproverType) Bytes() []byte

+ func (a ApproverType) String() string

+ type Attachment struct

+ func AttachmentFromBytes(bytes []byte) (result *Attachment, consumedBytes int, err error)

+ func NewAttachment(transactionID ledgerstate.TransactionID, messageID MessageID) *Attachment

+ func ParseAttachment(marshalUtil *marshalutil.MarshalUtil) (result *Attachment, err error)

+ func (a *Attachment) Bytes() []byte

+ func (a *Attachment) MessageID() MessageID

+ func (a *Attachment) ObjectStorageKey() []byte

+ func (a *Attachment) ObjectStorageValue() (data []byte)

+ func (a *Attachment) String() string

+ func (a *Attachment) TransactionID() ledgerstate.TransactionID

+ func (a *Attachment) Update(other objectstorage.StorableObject)

+ type Booker struct

+ Events *BookerEvents

+ MarkerBranchIDMappingManager *MarkerBranchIDMappingManager

+ MarkersManager *MarkersManager

+ func NewBooker(tangle *Tangle) (messageBooker *Booker)

+ func (m *Booker) Book(messageID MessageID) (err error)

+ func (m *Booker) Shutdown()

+ type BookerEvents struct

+ MessageBooked *events.Event

type CachedApprovers

+ func (c CachedApprovers) Release(force ...bool)

+ func (c CachedApprovers) String() string

+ func (c CachedApprovers) Unwrap() (unwrappedApprovers []*Approver)

+ type CachedAttachment struct

+ func (cachedAttachment *CachedAttachment) Consume(consumer func(attachment *Attachment)) (consumed bool)

+ func (cachedAttachment *CachedAttachment) Retain() *CachedAttachment

+ func (cachedAttachment *CachedAttachment) Unwrap() *Attachment

+ type CachedAttachments []*CachedAttachment

+ func (cachedAttachments CachedAttachments) Consume(consumer func(attachment *Attachment)) (consumed bool)

+ type CachedMarkerIndexBranchIDMapping struct

+ func (c *CachedMarkerIndexBranchIDMapping) Consume(consumer func(markerIndexBranchIDMapping *MarkerIndexBranchIDMapping), ...) (consumed bool)

+ func (c *CachedMarkerIndexBranchIDMapping) Retain() *CachedMarkerIndexBranchIDMapping

+ func (c *CachedMarkerIndexBranchIDMapping) String() string

+ func (c *CachedMarkerIndexBranchIDMapping) Unwrap() *MarkerIndexBranchIDMapping

type CachedMessageMetadata

+ func (c *CachedMessageMetadata) Consume(consumer func(messageMetadata *MessageMetadata), forceRelease ...bool) (consumed bool)

+ func (c *CachedMessageMetadata) ID() (messageID MessageID)

+ type CachedMissingMessage struct

+ func (c *CachedMissingMessage) Consume(consumer func(missingMessage *MissingMessage), forceRelease ...bool) (consumed bool)

+ func (c *CachedMissingMessage) ID() (id MessageID)

+ func (c *CachedMissingMessage) Retain() *CachedMissingMessage

+ func (c *CachedMissingMessage) String() string

+ func (c *CachedMissingMessage) Unwrap() *MissingMessage

+ type CachedOpinion struct

+ func (c *CachedOpinion) Consume(consumer func(opinion *Opinion), forceRelease ...bool) (consumed bool)

+ func (c *CachedOpinion) Retain() *CachedOpinion

+ func (c *CachedOpinion) String() string

+ func (c *CachedOpinion) Unwrap() *Opinion

+ type ConflictSet []OpinionEssence

type Events

+ Error *events.Event

+ MessageEligible *events.Event

+ MessageInvalid *events.Event

+ type FCoB struct

+ Events *FCoBEvents

+ func NewFCoB(store kvstore.KVStore, tangle *Tangle) (fcob *FCoB)

+ func (f *FCoB) CachedOpinion(transactionID ledgerstate.TransactionID) (cachedOpinion *CachedOpinion)

+ func (f *FCoB) Evaluate(messageID MessageID)

+ func (f *FCoB) Opinion(messageID MessageID) (opinion bool)

+ func (f *FCoB) OpinionEssence(transactionID ledgerstate.TransactionID) (opinion OpinionEssence)

+ func (f *FCoB) OpinionsEssence(conflictSet ledgerstate.TransactionIDs) (opinions []OpinionEssence)

+ func (f *FCoB) ProcessVote(ev *vote.OpinionEvent)

+ func (f *FCoB) Setup(payloadEvent *events.Event)

+ func (f *FCoB) Shutdown()

+ func (f *FCoB) Vote() *events.Event

+ func (f *FCoB) VoteError() *events.Event

+ type FCoBEvents struct

+ Error *events.Event

+ PayloadOpinionFormed *events.Event

+ Vote *events.Event

+ type LedgerState struct

+ func NewLedgerState(tangle *Tangle) (ledgerState *LedgerState)

+ func (l *LedgerState) BookTransaction(transaction *ledgerstate.Transaction, messageID MessageID) (targetBranch ledgerstate.BranchID, err error)

+ func (l *LedgerState) BranchID(transactionID ledgerstate.TransactionID) (branchID ledgerstate.BranchID)

+ func (l *LedgerState) BranchInclusionState(branchID ledgerstate.BranchID) (inclusionState ledgerstate.InclusionState)

+ func (l *LedgerState) ConflictSet(transactionID ledgerstate.TransactionID) (conflictSet ledgerstate.TransactionIDs)

+ func (l *LedgerState) InheritBranch(referencedBranchIDs ledgerstate.BranchIDs) (inheritedBranch ledgerstate.BranchID, err error)

+ func (l *LedgerState) LoadSnapshot(...)

+ func (l *LedgerState) Shutdown()

+ func (l *LedgerState) TransactionConflicting(transactionID ledgerstate.TransactionID) bool

+ func (l *LedgerState) TransactionInclusionState(transactionID ledgerstate.TransactionID) (ledgerstate.InclusionState, error)

+ func (l *LedgerState) TransactionMetadata(transactionID ledgerstate.TransactionID) (cachedTransactionMetadata *ledgerstate.CachedTransactionMetadata)

+ func (l *LedgerState) TransactionValid(transaction *ledgerstate.Transaction, messageID MessageID) (valid bool)

+ type LevelOfKnowledge = uint8

+ const One

+ const Pending

+ const Three

+ const Two

+ type MarkerBranchIDMappingManager struct

+ func NewMarkerBranchIDMappingManager(tangle *Tangle) (markerBranchIDMappingManager *MarkerBranchIDMappingManager)

+ func (m *MarkerBranchIDMappingManager) BranchID(marker *markers.Marker) (branchID ledgerstate.BranchID)

+ func (m *MarkerBranchIDMappingManager) SetBranchID(marker *markers.Marker, branchID ledgerstate.BranchID)

+ type MarkerIndexBranchIDMapping struct

+ func MarkerIndexBranchIDMappingFromBytes(bytes []byte) (markerIndexBranchIDMapping *MarkerIndexBranchIDMapping, consumedBytes int, ...)

+ func MarkerIndexBranchIDMappingFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (markerIndexBranchIDMapping *MarkerIndexBranchIDMapping, err error)

+ func NewMarkerIndexBranchIDMapping(sequenceID markers.SequenceID) (markerBranchMapping *MarkerIndexBranchIDMapping)

+ func (m *MarkerIndexBranchIDMapping) BranchID(markerIndex markers.Index) (branchID ledgerstate.BranchID)

+ func (m *MarkerIndexBranchIDMapping) Bytes() []byte

+ func (m *MarkerIndexBranchIDMapping) ObjectStorageKey() []byte

+ func (m *MarkerIndexBranchIDMapping) ObjectStorageValue() []byte

+ func (m *MarkerIndexBranchIDMapping) SequenceID() markers.SequenceID

+ func (m *MarkerIndexBranchIDMapping) SetBranchID(index markers.Index, branchID ledgerstate.BranchID)

+ func (m *MarkerIndexBranchIDMapping) String() string

+ func (m *MarkerIndexBranchIDMapping) Update(other objectstorage.StorableObject)

+ type MarkersManager struct

+ func NewMarkersManager(tangle *Tangle) *MarkersManager

+ func (m *MarkersManager) InheritStructureDetails(message *Message, branchID ledgerstate.BranchID) (structureDetails *markers.StructureDetails)

type Message

+ func (m *Message) Parents() (parents MessageIDs)

type MessageMetadata

+ func (m *MessageMetadata) BranchID() ledgerstate.BranchID

+ func (m *MessageMetadata) ID() MessageID

+ func (m *MessageMetadata) IsBooked() (result bool)

+ func (m *MessageMetadata) IsEligible() (result bool)

+ func (m *MessageMetadata) IsInvalid() (result bool)

+ func (m *MessageMetadata) SetBooked(booked bool) (modified bool)

+ func (m *MessageMetadata) SetBranchID(ID ledgerstate.BranchID) (modified bool)

+ func (m *MessageMetadata) SetEligible(eligible bool) (modified bool)

+ func (m *MessageMetadata) SetInvalid(invalid bool) (modified bool)

+ func (m *MessageMetadata) SetStructureDetails(structureDetails *markers.StructureDetails) (modified bool)

+ func (m *MessageMetadata) SetTimestampOpinion(timestampOpinion TimestampOpinion) (modified bool)

+ func (m *MessageMetadata) StructureDetails() *markers.StructureDetails

+ func (m *MessageMetadata) TimestampOpinion() (timestampOpinion TimestampOpinion)

+ type MessageToSchedule struct

+ ID MessageID

+ type OldTangle struct

+ Events *Events

+ func Old(store kvstore.KVStore) (result *OldTangle)

+ func (t *OldTangle) CheckParentsEligibility(cachedMessage *CachedMessage, cachedMsgMetadata *CachedMessageMetadata)

+ type Opinion struct

+ func OpinionFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *Opinion, err error)

+ func (o *Opinion) Bytes() []byte

+ func (o *Opinion) LevelOfKnowledge() LevelOfKnowledge

+ func (o *Opinion) Liked() bool

+ func (o *Opinion) ObjectStorageKey() []byte

+ func (o *Opinion) ObjectStorageValue() []byte

+ func (o *Opinion) SetLevelOfKnowledge(lok LevelOfKnowledge)

+ func (o *Opinion) SetLiked(l bool)

+ func (o *Opinion) SetTimestamp(t time.Time)

+ func (o *Opinion) String() string

+ func (o *Opinion) Timestamp() time.Time

+ func (o *Opinion) Update(other objectstorage.StorableObject)

+ type OpinionEssence struct

+ type OpinionFormedEvent struct

+ MessageID MessageID

+ Opinion bool

+ type OpinionFormer struct

+ Events OpinionFormerEvents

+ TimestampOpinionProvider OpinionProvider

+ func NewOpinionFormer(tangle *Tangle, payloadOpinionVoterProvider OpinionVoterProvider, ...) (opinionFormer *OpinionFormer)

+ func (o *OpinionFormer) MessageEligible(messageID MessageID) (eligible bool)

+ func (o *OpinionFormer) PayloadLiked(messageID MessageID) (liked bool)

+ func (o *OpinionFormer) Setup()

+ func (o *OpinionFormer) Shutdown()

+ type OpinionFormerEvents struct

+ MessageOpinionFormed *events.Event

+ PayloadOpinionFormed *events.Event

+ TimestampOpinionFormed *events.Event

+ type OpinionProvider interface

+ Evaluate func(MessageID)

+ Opinion func(MessageID) bool

+ Setup func(*events.Event)

+ Shutdown func()

+ type OpinionVoterProvider interface

+ ProcessVote func(*vote.OpinionEvent)

+ Vote func() *events.Event

+ VoteError func() *events.Event

type Option

+ func Identity(identity *identity.LocalIdentity) Option

+ func Store(store kvstore.KVStore) Option

+ func WithoutOpinionFormer(with bool) Option

type Options

+ Identity *identity.LocalIdentity

+ Store kvstore.KVStore

+ WithoutOpinionFormer bool

+ type Parser struct

+ Events *ParserEvents

+ func NewParser() (result *Parser)

+ func (p *Parser) AddBytesFilter(filter BytesFilter)

+ func (p *Parser) AddMessageFilter(filter MessageFilter)

+ func (p *Parser) Parse(messageBytes []byte, peer *peer.Peer)

+ func (p *Parser) Setup()

+ type ParserEvents struct

+ BytesRejected *events.Event

+ MessageParsed *events.Event

+ MessageRejected *events.Event

+ type Requester struct

+ Events *MessageRequesterEvents

+ func NewRequester(tangle *Tangle, optionalOptions ...RequesterOption) *Requester

+ func (r *Requester) RequestQueueSize() int

+ func (r *Requester) Setup()

+ func (r *Requester) StartRequest(id MessageID)

+ func (r *Requester) StopRequest(id MessageID)

+ type RequesterOption func(*RequesterOptions)

+ type RequesterOptions struct

+ type Scheduler struct

+ Events *SchedulerEvents

+ func NewScheduler(tangle *Tangle) (scheduler *Scheduler)

+ func (s *Scheduler) Setup()

+ func (s *Scheduler) Shutdown()

+ type SchedulerEvents struct

+ MessageScheduled *events.Event

+ type SchedulerParentPriorityMap map[MessageID][]*MessageToSchedule

+ type Solidifier struct

+ Events *SolidifierEvents

+ func NewSolidifier(tangle *Tangle) (solidifier *Solidifier)

+ func (s *Solidifier) Setup()

+ func (s *Solidifier) Solidify(messageID MessageID)

+ type SolidifierEvents struct

+ MessageMissing *events.Event

+ MessageSolid *events.Event

+ type Storage struct

+ Events *StorageEvents

+ func NewStorage(tangle *Tangle) (result *Storage)

+ func (s *Storage) Approvers(messageID MessageID, optionalApproverType ...ApproverType) (cachedApprovers CachedApprovers)

+ func (s *Storage) AttachmentMessageIDs(transactionID ledgerstate.TransactionID) (messageIDs MessageIDs)

+ func (s *Storage) Attachments(transactionID ledgerstate.TransactionID) (cachedAttachments CachedAttachments)

+ func (s *Storage) DBStats() (solidCount int, messageCount int, avgSolidificationTime float64, ...)

+ func (s *Storage) DeleteMessage(messageID MessageID)

+ func (s *Storage) DeleteMissingMessage(messageID MessageID)

+ func (s *Storage) MarkerIndexBranchIDMapping(sequenceID markers.SequenceID, ...) *CachedMarkerIndexBranchIDMapping

+ func (s *Storage) Message(messageID MessageID) *CachedMessage

+ func (s *Storage) MessageMetadata(messageID MessageID, computeIfAbsentCallback ...func() *MessageMetadata) *CachedMessageMetadata

+ func (s *Storage) MissingMessages() (ids []MessageID)

+ func (s *Storage) Prune() error

+ func (s *Storage) RetrieveAllTips() (tips []MessageID)

+ func (s *Storage) Setup()

+ func (s *Storage) Shutdown()

+ func (s *Storage) StoreAttachment(transactionID ledgerstate.TransactionID, messageID MessageID) (cachedAttachment *CachedAttachment, stored bool)

+ func (s *Storage) StoreMessage(message *Message)

+ func (s *Storage) StoreMissingMessage(missingMessage *MissingMessage) (cachedMissingMessage *CachedMissingMessage, stored bool)

+ type StorageEvents struct

+ MessageRemoved *events.Event

+ MessageStored *events.Event

+ MissingMessageStored *events.Event

type Tangle

+ Booker *Booker

+ LedgerState *LedgerState

+ MessageFactory *MessageFactory

+ OpinionFormer *OpinionFormer

+ Options *Options

+ Parser *Parser

+ PayloadOpinionProvider OpinionVoterProvider

+ Requester *Requester

+ Scheduler *Scheduler

+ Solidifier *Solidifier

+ Storage *Storage

+ TimestampOpinionProvider OpinionProvider

+ TipManager *TipManager

+ Utils *Utils

+ func (t *Tangle) ProcessGossipMessage(messageBytes []byte, peer *peer.Peer)

+ func (t *Tangle) Setup()

+ type TimeMessageQueue struct

+ C chan *MessageToSchedule

+ func NewTimeMessageQueue(capacity int) *TimeMessageQueue

+ func (t *TimeMessageQueue) Add(message *MessageToSchedule)

+ func (t *TimeMessageQueue) Pop() (message *MessageToSchedule)

+ func (t *TimeMessageQueue) Start()

+ func (t *TimeMessageQueue) Stop()

+ type TimestampLikedByDefault struct

+ Events *TimestampLikedByDefaultEvents

+ func NewTimestampLikedByDefault(tangle *Tangle) (timestampByDefault *TimestampLikedByDefault)

+ func (t *TimestampLikedByDefault) Evaluate(messageID MessageID)

+ func (t *TimestampLikedByDefault) Opinion(messageID MessageID) (opinion bool)

+ func (t *TimestampLikedByDefault) Setup(timestampEvent *events.Event)

+ func (t *TimestampLikedByDefault) Shutdown()

+ type TimestampLikedByDefaultEvents struct

+ TimestampOpinionFormed *events.Event

+ type TimestampOpinion struct

+ LoK LevelOfKnowledge

+ Value opinion.Opinion

+ func TimestampOpinionFromBytes(bytes []byte) (timestampOpinion TimestampOpinion, consumedBytes int, err error)

+ func TimestampOpinionFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result TimestampOpinion, err error)

+ func TimestampQuality(target, current time.Time) (timestampOpinion TimestampOpinion)

+ func (t TimestampOpinion) Bytes() (bytes []byte)

+ func (t TimestampOpinion) Equal(x TimestampOpinion) bool

+ type TipManager struct

+ Events *TipManagerEvents

+ func NewTipManager(tangle *Tangle, tips ...MessageID) *TipManager

+ func (t *TipManager) AddTip(msg *Message)

+ func (t *TipManager) Set(tips ...MessageID)

+ func (t *TipManager) Setup()

+ func (t *TipManager) TipCount() int

+ func (t *TipManager) Tips(count int) (parents []MessageID)

+ type TipManagerEvents struct

+ TipAdded *events.Event

+ TipRemoved *events.Event

+ type TransactionFilter struct

+ func NewTransactionFilter() *TransactionFilter

+ func (f *TransactionFilter) Filter(msg *Message, peer *peer.Peer)

+ func (f *TransactionFilter) OnAccept(callback func(msg *Message, peer *peer.Peer))

+ func (f *TransactionFilter) OnReject(callback func(msg *Message, err error, peer *peer.Peer))

+ type Utils struct

+ func NewUtils(tangle *Tangle) (utils *Utils)

+ func (u *Utils) ApprovingMessageIDs(messageID MessageID, optionalApproverType ...ApproverType) (approvingMessageIDs MessageIDs)

+ func (u *Utils) ComputeIfTransaction(messageID MessageID, compute func(ledgerstate.TransactionID)) (computed bool)

+ func (u *Utils) MessageApprovedBy(approvedMessageID MessageID, approvingMessageID MessageID) (approved bool)

+ func (u *Utils) MessageStronglyApprovedBy(approvedMessageID MessageID, approvingMessageID MessageID) (stronglyApproved bool)

+ func (u *Utils) WalkMessage(callback func(message *Message, walker *walker.Walker), entryPoints MessageIDs, ...)

+ func (u *Utils) WalkMessageAndMetadata(...)

+ func (u *Utils) WalkMessageID(callback func(messageID MessageID, walker *walker.Walker), ...)

+ func (u *Utils) WalkMessageMetadata(callback func(messageMetadata *MessageMetadata, walker *walker.Walker), ...)

v0.3.5

Jan 13, 2021

v0.3.4

Dec 11, 2020

v0.3.3

Dec 10, 2020

v0.3.2

Dec 9, 2020

v0.3.1

Nov 13, 2020

Changes in this version

+ const MaxParentsCount

+ const MessageVersion

+ const MinParentsCount

+ const MinStrongParentsCount

+ const StrongParent

+ const WeakParent

type Message

+ func (m *Message) ForEachParent(consumer func(parent Parent))

+ func (m *Message) ForEachStrongParent(consumer func(parent MessageID))

+ func (m *Message) ForEachWeakParent(consumer func(parent MessageID))

+ func (m *Message) ParentsCount() uint8

+ func (m *Message) StrongParents() MessageIDs

+ func (m *Message) Version() uint8

+ func (m *Message) WeakParents() MessageIDs

+ type MessageIDs []MessageID

+ func (ids MessageIDs) ToStrings() []string

+ type Parent struct

+ ID MessageID

+ Type uint8

v0.3.0

Oct 12, 2020

Changes in this version

+ const ContentIDLength

+ const DBSequenceNumber

+ const DefaultRetryInterval

+ const MaxMessageSize

+ const MessageIDLength

+ const PrefixApprovers

+ const PrefixMessage

+ const PrefixMessageMetadata

+ const PrefixMissingMessage

+ var EmptyMessageID = MessageID

+ var ErrInvalidPOWDifficultly = errors.New("invalid PoW")

+ var ErrInvalidSignature = fmt.Errorf("invalid signature")

+ var ErrMessageTooSmall = errors.New("message too small")

+ var ErrReceivedDuplicateBytes = fmt.Errorf("received duplicate bytes")

+ var ZeroWorker = WorkerFunc(func([]byte) (uint64, error) { ... })

+ func ApproverFromObjectStorage(key []byte, _ []byte) (result objectstorage.StorableObject, err error)

+ func MessageFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error)

+ func MessageMetadataFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error)

+ func MissingMessageFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error)

+ type Approver struct

+ func ApproverFromBytes(bytes []byte) (result *Approver, consumedBytes int, err error)

+ func ApproverFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *Approver, err error)

+ func NewApprover(referencedMessageID MessageID, approverMessageID MessageID) *Approver

+ func (a *Approver) ApproverMessageID() MessageID

+ func (a *Approver) Bytes() []byte

+ func (a *Approver) ObjectStorageKey() []byte

+ func (a *Approver) ObjectStorageValue() (result []byte)

+ func (a *Approver) ReferencedMessageID() MessageID

+ func (a *Approver) String() string

+ func (a *Approver) Update(other objectstorage.StorableObject)

+ type BytesFilter interface

+ Filter func(bytes []byte, peer *peer.Peer)

+ OnAccept func(callback func(bytes []byte, peer *peer.Peer))

+ OnReject func(callback func(bytes []byte, err error, peer *peer.Peer))

+ type BytesRejectedEvent struct

+ Bytes []byte

+ Peer *peer.Peer

+ type CachedApprover struct

+ func (c *CachedApprover) Consume(consumer func(approver *Approver)) (consumed bool)

+ func (c *CachedApprover) Unwrap() *Approver

+ type CachedApprovers []*CachedApprover

+ func (c CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool)

+ type CachedMessage struct

+ func (c *CachedMessage) Consume(consumer func(msg *Message)) bool

+ func (c *CachedMessage) Retain() *CachedMessage

+ func (c *CachedMessage) Unwrap() *Message

+ type CachedMessageEvent struct

+ Message *CachedMessage

+ MessageMetadata *CachedMessageMetadata

+ type CachedMessageMetadata struct

+ func (c *CachedMessageMetadata) Retain() *CachedMessageMetadata

+ func (c *CachedMessageMetadata) Unwrap() *MessageMetadata

+ type ContentID = MessageID

+ type Events struct

+ MessageAttached *events.Event

+ MessageMissing *events.Event

+ MessageRemoved *events.Event

+ MessageSolid *events.Event

+ MessageUnsolidifiable *events.Event

+ MissingMessageReceived *events.Event

+ type Message struct

+ func MessageFromBytes(bytes []byte) (result *Message, consumedBytes int, err error)

+ func MessageFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *Message, err error)

+ func NewMessage(parent1ID MessageID, parent2ID MessageID, issuingTime time.Time, ...) (result *Message)

+ func (m *Message) Bytes() []byte

+ func (m *Message) ContentID() (result ContentID)

+ func (m *Message) ID() (result MessageID)

+ func (m *Message) IssuerPublicKey() ed25519.PublicKey

+ func (m *Message) IssuingTime() time.Time

+ func (m *Message) Nonce() uint64

+ func (m *Message) ObjectStorageKey() []byte

+ func (m *Message) ObjectStorageValue() []byte

+ func (m *Message) Parent1ID() MessageID

+ func (m *Message) Parent2ID() MessageID

+ func (m *Message) Payload() payload.Payload

+ func (m *Message) SequenceNumber() uint64

+ func (m *Message) Signature() ed25519.Signature

+ func (m *Message) String() string

+ func (m *Message) Update(objectstorage.StorableObject)

+ func (m *Message) VerifySignature() bool

+ type MessageExistsFunc func(messageId MessageID) bool

+ type MessageFactory struct

+ Events *MessageFactoryEvents

+ func NewMessageFactory(store kvstore.KVStore, sequenceKey []byte, ...) *MessageFactory

+ func (f *MessageFactory) IssuePayload(p payload.Payload) (*Message, error)

+ func (f *MessageFactory) SetWorker(worker Worker)

+ func (f *MessageFactory) Shutdown()

+ type MessageFactoryEvents struct

+ Error *events.Event

+ MessageConstructed *events.Event

+ type MessageFilter interface

+ Filter func(msg *Message, peer *peer.Peer)

+ OnAccept func(callback func(msg *Message, peer *peer.Peer))

+ OnReject func(callback func(msg *Message, err error, peer *peer.Peer))

+ type MessageID [MessageIDLength]byte

+ func MessageIDFromBytes(bytes []byte) (result MessageID, consumedBytes int, err error)

+ func MessageIDFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (MessageID, error)

+ func NewMessageID(base58EncodedString string) (result MessageID, err error)

+ func (id *MessageID) MarshalBinary() (result []byte, err error)

+ func (id *MessageID) UnmarshalBinary(data []byte) (err error)

+ func (id MessageID) Bytes() []byte

+ func (id MessageID) String() string

+ type MessageMetadata struct

+ func MessageMetadataFromBytes(bytes []byte) (result *MessageMetadata, consumedBytes int, err error)

+ func MessageMetadataFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *MessageMetadata, err error)

+ func NewMessageMetadata(messageID MessageID) *MessageMetadata

+ func (m *MessageMetadata) Bytes() []byte

+ func (m *MessageMetadata) IsSolid() (result bool)

+ func (m *MessageMetadata) ObjectStorageKey() []byte

+ func (m *MessageMetadata) ObjectStorageValue() []byte

+ func (m *MessageMetadata) ReceivedTime() time.Time

+ func (m *MessageMetadata) SetSolid(solid bool) (modified bool)

+ func (m *MessageMetadata) SolidificationTime() time.Time

+ func (m *MessageMetadata) Update(other objectstorage.StorableObject)

+ type MessageParsedEvent struct

+ Message *Message

+ Peer *peer.Peer

+ type MessageParser struct

+ Events *MessageParserEvents

+ func NewMessageParser() (result *MessageParser)

+ func (p *MessageParser) AddBytesFilter(filter BytesFilter)

+ func (p *MessageParser) AddMessageFilter(filter MessageFilter)

+ func (p *MessageParser) Parse(messageBytes []byte, peer *peer.Peer)

+ type MessageParserEvents struct

+ BytesRejected *events.Event

+ MessageParsed *events.Event

+ MessageRejected *events.Event

+ type MessageRejectedEvent struct

+ Message *Message

+ Peer *peer.Peer

+ type MessageRequester struct

+ Events *MessageRequesterEvents

+ func NewMessageRequester(missingMessages []MessageID, optionalOptions ...Option) *MessageRequester

+ func (r *MessageRequester) RequestQueueSize() int

+ func (r *MessageRequester) StartRequest(id MessageID)

+ func (r *MessageRequester) StopRequest(id MessageID)

+ type MessageRequesterEvents struct

+ MissingMessageAppeared *events.Event

+ SendRequest *events.Event

+ type MessageSignatureFilter struct

+ func NewMessageSignatureFilter() *MessageSignatureFilter

+ func (f *MessageSignatureFilter) Filter(msg *Message, peer *peer.Peer)

+ func (f *MessageSignatureFilter) OnAccept(callback func(msg *Message, peer *peer.Peer))

+ func (f *MessageSignatureFilter) OnReject(callback func(msg *Message, err error, peer *peer.Peer))

+ type MessageTipSelector struct

+ Events *MessageTipSelectorEvents

+ func NewMessageTipSelector(tips ...MessageID) *MessageTipSelector

+ func (t *MessageTipSelector) AddTip(msg *Message)

+ func (t *MessageTipSelector) Set(tips ...MessageID)

+ func (t *MessageTipSelector) TipCount() int

+ func (t *MessageTipSelector) Tips() (parent1MessageID, parent2MessageID MessageID)

+ type MessageTipSelectorEvents struct

+ TipAdded *events.Event

+ TipRemoved *events.Event

+ type MissingMessage struct

+ func MissingMessageFromBytes(bytes []byte) (result *MissingMessage, consumedBytes int, err error)

+ func MissingMessageFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *MissingMessage, err error)

+ func NewMissingMessage(messageID MessageID) *MissingMessage

+ func (m *MissingMessage) Bytes() []byte

+ func (m *MissingMessage) MessageID() MessageID

+ func (m *MissingMessage) MissingSince() time.Time

+ func (m *MissingMessage) ObjectStorageKey() []byte

+ func (m *MissingMessage) ObjectStorageValue() (result []byte)

+ func (m *MissingMessage) Update(other objectstorage.StorableObject)

+ type MissingMessageAppearedEvent struct

+ ID MessageID

+ type Option func(*Options)

+ func RetryInterval(interval time.Duration) Option

+ type Options struct

+ type PowFilter struct

+ func NewPowFilter(worker *pow.Worker, difficulty int) *PowFilter

+ func (f *PowFilter) Filter(msgBytes []byte, p *peer.Peer)

+ func (f *PowFilter) OnAccept(callback func([]byte, *peer.Peer))

+ func (f *PowFilter) OnReject(callback func([]byte, error, *peer.Peer))

+ type RecentlySeenBytesFilter struct

+ func NewRecentlySeenBytesFilter() *RecentlySeenBytesFilter

+ func (f *RecentlySeenBytesFilter) Filter(bytes []byte, peer *peer.Peer)

+ func (f *RecentlySeenBytesFilter) OnAccept(callback func(bytes []byte, peer *peer.Peer))

+ func (f *RecentlySeenBytesFilter) OnReject(callback func(bytes []byte, err error, peer *peer.Peer))

+ type SendRequestEvent struct

+ ID MessageID

+ type Tangle struct

+ Events *Events

+ func New(store kvstore.KVStore) (result *Tangle)

+ func (t *Tangle) Approvers(messageID MessageID) CachedApprovers

+ func (t *Tangle) AttachMessage(msg *Message)

+ func (t *Tangle) DBStats() (solidCount int, messageCount int, avgSolidificationTime float64, ...)

+ func (t *Tangle) DeleteMessage(messageID MessageID)

+ func (t *Tangle) DeleteMissingMessage(messageID MessageID)

+ func (t *Tangle) Message(messageID MessageID) *CachedMessage

+ func (t *Tangle) MessageMetadata(messageID MessageID) *CachedMessageMetadata

+ func (t *Tangle) MissingMessages() (ids []MessageID)

+ func (t *Tangle) Prune() error

+ func (t *Tangle) RetrieveAllTips() (tips []MessageID)

+ func (t *Tangle) Shutdown() *Tangle

+ func (t *Tangle) SolidifierWorkerPoolStatus() (name string, load int)

+ func (t *Tangle) StoreMessageWorkerPoolStatus() (name string, load int)

+ type TipSelector interface

+ Tips func() (parent1 MessageID, parent2 MessageID)

+ type TipSelectorFunc func() (MessageID, MessageID)

+ func (f TipSelectorFunc) Tips() (MessageID, MessageID)

+ type Worker interface

+ DoPOW func([]byte) (nonce uint64, err error)

+ type WorkerFunc func([]byte) (uint64, error)

+ func (f WorkerFunc) DoPOW(msg []byte) (uint64, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL