mana

Jul 14, 2022

Changes in this version

type BaseManaVector

+ BookEpoch func(created []*ledger.OutputWithMetadata, spent []*ledger.OutputWithMetadata)

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

type ManaBaseVector

+ func (m *ManaBaseVector) BookEpoch(created []*ledger.OutputWithMetadata, spent []*ledger.OutputWithMetadata)

+ func (m *ManaBaseVector) InitializeWithData(dataByNode map[identity.ID]float64)

Jun 22, 2022

Changes in this version

+ type ManaBase struct

+ func NewManaBase(value float64) *ManaBase

+ func (m *ManaBase) BaseValue() float64

+ type ManaBaseVector struct

+ func (m *ManaBaseVector) Book(txInfo *TxInfo)

+ func (m *ManaBaseVector) ForEach(callback func(ID identity.ID, bm BaseMana) bool)

+ func (m *ManaBaseVector) FromPersistable(p *PersistableBaseMana) (err error)

+ func (m *ManaBaseVector) GetHighestManaNodes(n uint) (res []Node, t time.Time, err error)

+ func (m *ManaBaseVector) GetHighestManaNodesFraction(p float64) (res []Node, t time.Time, err error)

+ func (m *ManaBaseVector) GetMana(nodeID identity.ID) (float64, time.Time, error)

+ func (m *ManaBaseVector) GetManaMap() (res NodeMap, t time.Time, err error)

+ func (m *ManaBaseVector) Has(nodeID identity.ID) bool

+ func (m *ManaBaseVector) LoadSnapshot(snapshot map[identity.ID]*SnapshotNode)

+ func (m *ManaBaseVector) RemoveZeroNodes()

+ func (m *ManaBaseVector) SetMana(nodeID identity.ID, bm BaseMana)

+ func (m *ManaBaseVector) Size() int

+ func (m *ManaBaseVector) ToPersistables() []*PersistableBaseMana

+ func (m *ManaBaseVector) Type() Type

+ func (m *ManaBaseVector) Vector() map[identity.ID]*ManaBase

Jun 16, 2022

Changes in this version

type AccessBaseMana

+ func NewAccessBaseMana(baseMana, effectiveBaseMana float64, lastUpdated time.Time) (newAccessBaseMana *AccessBaseMana)

type AccessBaseManaVector

+ func (a *AccessBaseManaVector) Vector() map[identity.ID]*AccessBaseMana

+ type AccessManaRecord struct

+ Timestamp time.Time

+ Value float64

type AccessManaSnapshot

+ func (a *AccessManaSnapshot) Bytes() (serialized []byte)

+ func (a *AccessManaSnapshot) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (err error)

+ func (a AccessManaSnapshot) String() (humanReadable string)

type ConsensusBaseMana

+ func NewConsensusBaseMana(baseMana float64) *ConsensusBaseMana

type ConsensusBaseManaVector

+ func (c *ConsensusBaseManaVector) Vector() map[identity.ID]*ConsensusBaseMana

+ type ManaEvents struct

+ Pledged *event.Event[*PledgedEvent]

+ Revoked *event.Event[*RevokedEvent]

+ Updated *event.Event[*UpdatedEvent]

type PersistableBaseMana

+ func NewPersistableBaseMana(nodeID identity.ID, manaType Type, baseValues, effectiveValues []float64, ...) *PersistableBaseMana

+ type Snapshot struct

+ ByNodeID map[identity.ID]*SnapshotNode

+ func NewSnapshot() *Snapshot

+ func (s *Snapshot) Bytes() (serialized []byte)

+ func (s *Snapshot) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (err error)

+ func (s *Snapshot) MaxAccessManaUpdateTime() (maxTime time.Time)

+ func (s *Snapshot) NodeSnapshot(nodeID identity.ID) (nodeSnapshot *SnapshotNode)

+ func (s *Snapshot) ResetTime()

+ func (s *Snapshot) String() (humanReadable string)

type SnapshotNode

+ func (s *SnapshotNode) AccessManaUpdateTime() (maxTime time.Time)

+ func (s *SnapshotNode) AdjustAccessManaUpdateTime(diff time.Duration)

+ func (s *SnapshotNode) Bytes() (serialized []byte)

+ func (s *SnapshotNode) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (err error)

+ func (s *SnapshotNode) String() (humanReadable string)

type SortedTxSnapshot

+ func (s *SortedTxSnapshot) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (err error)

+ func (s SortedTxSnapshot) Bytes() (serialized []byte)

+ func (s SortedTxSnapshot) String() (humanReadable string)

type TxSnapshot

+ func (t *TxSnapshot) Bytes() (serialized []byte)

+ func (t *TxSnapshot) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (err error)

+ func (t *TxSnapshot) String() (humanReadable string)

Mar 14, 2022

Changes in this version

type ConsensusBasePastManaVectorMetadata

+ func (*ConsensusBasePastManaVectorMetadata) FromBytes(data []byte) (result *ConsensusBasePastManaVectorMetadata, err error)

+ func (c *ConsensusBasePastManaVectorMetadata) FromObjectStorage(_, bytes []byte) (objectstorage.StorableObject, error)

type PersistableBaseMana

+ func (p *PersistableBaseMana) FromBytes(bytes []byte) (result *PersistableBaseMana, err error)

+ func (p *PersistableBaseMana) FromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (persistableBaseMana *PersistableBaseMana, err error)

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

type PersistableEvent

+ func (p *PersistableEvent) FromBytes(data []byte) (result *PersistableEvent, err error)

+ func (p *PersistableEvent) FromObjectStorage(_, bytes []byte) (objectstorage.StorableObject, error)

Sep 23, 2021

Changes in this version

+ type ManaRetrievalFunc func(identity.ID, ...time.Time) (float64, time.Time, error)

May 24, 2021

Changes in this version

+ type AccessManaSnapshot struct

+ Timestamp time.Time

+ Value float64

+ type SnapshotNode struct

+ AccessMana AccessManaSnapshot

+ SortedTxSnapshot SortedTxSnapshot

+ type SortedTxSnapshot []*TxSnapshot

+ func (s SortedTxSnapshot) Len() int

+ func (s SortedTxSnapshot) Less(i, j int) bool

+ func (s SortedTxSnapshot) Swap(i, j int)

+ type TxSnapshot struct

+ Timestamp time.Time

+ TxID ledgerstate.TransactionID

+ Value float64

Apr 23, 2021

Changes in this version

type AccessBaseManaVector

+ func (a *AccessBaseManaVector) LoadSnapshot(snapshot map[identity.ID]*SnapshotInfo, snapshotTime time.Time)

type BaseManaVector

+ LoadSnapshot func(map[identity.ID]*SnapshotInfo, time.Time)

type ConsensusBaseManaVector

+ func (c *ConsensusBaseManaVector) LoadSnapshot(snapshot map[identity.ID]*SnapshotInfo, snapshotTime time.Time)

type Event

+ String func() string

type PledgedEvent

+ func (p *PledgedEvent) String() string

type RevokedEvent

+ func (r *RevokedEvent) String() string

+ type SnapshotInfo struct

+ TxID ledgerstate.TransactionID

+ Value float64

type UpdatedEvent

+ func (u *UpdatedEvent) String() string

type WeightedBaseManaVector

+ func (w *WeightedBaseManaVector) LoadSnapshot(snapshot map[identity.ID]*SnapshotInfo, snapshotTime time.Time)

Apr 1, 2021

Changes in this version

type AccessBaseManaVector

+ func (a *AccessBaseManaVector) GetHighestManaNodesFraction(p float64) (res []Node, t time.Time, err error)

type BaseManaVector

+ GetHighestManaNodesFraction func(p float64) ([]Node, time.Time, error)

type ConsensusBaseManaVector

+ func (c *ConsensusBaseManaVector) GetHighestManaNodesFraction(p float64) (res []Node, t time.Time, err error)

type WeightedBaseManaVector

+ func (w *WeightedBaseManaVector) GetHighestManaNodesFraction(p float64) (res []Node, t time.Time, err error)

Mar 11, 2021

Changes in this version

+ const ConsensusBaseManaPastVectorMetadataStorageKey

+ const DeltaStopUpdate

+ const EventTypePledge

+ const EventTypeRevoke

+ const EventTypeUpdate

+ const MinBaseMana

+ const MinEffectiveMana

+ const Mixed

+ const OnlyMana1

+ const OnlyMana2

+ const PrefixAccess

+ const PrefixAccessResearch

+ const PrefixConsensus

+ const PrefixConsensusPastMetadata

+ const PrefixConsensusPastVector

+ const PrefixConsensusResearch

+ const PrefixEventStorage

+ var Decay = 0.00003209

+ var ErrAlreadyUpdated = errors.New("already updated to a later timestamp")

+ var ErrBaseManaNegative = errors.New("base mana should never be negative")

+ var ErrEffBaseManaNegative = errors.New("effective base mana should never be negative")

+ var ErrInvalidTargetManaType = errors.New("invalid target mana type")

+ var ErrInvalidWeightParameter = errors.New("invalid weight parameter, outside of [0,1]")

+ var ErrNodeNotFoundInBaseManaVector = errors.New("node not present in base mana vector")

+ var ErrUnknownManaEvent = errors.New("unknown mana event")

+ var ErrUnknownManaType = errors.New("unknown mana type")

+ func FromEventObjectStorage(_ []byte, data []byte) (result objectstorage.StorableObject, err error)

+ func FromMetadataObjectStorage(_ []byte, data []byte) (result objectstorage.StorableObject, err error)

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

+ func IDFromPubKey(pubKey string) (ID identity.ID, err error)

+ func IDFromStr(idStr string) (ID identity.ID, err error)

+ func SetCoefficients(ema1 float64, ema2 float64, dec float64)

+ type AccessBaseMana struct

+ BaseMana2 float64

+ EffectiveBaseMana2 float64

+ LastUpdated time.Time

+ func (a *AccessBaseMana) BaseValue() float64

+ func (a *AccessBaseMana) EffectiveValue() float64

+ func (a *AccessBaseMana) LastUpdate() time.Time

+ type AccessBaseManaVector struct

+ func (a *AccessBaseManaVector) Book(txInfo *TxInfo)

+ func (a *AccessBaseManaVector) ForEach(callback func(ID identity.ID, bm BaseMana) bool)

+ func (a *AccessBaseManaVector) FromPersistable(p *PersistableBaseMana) (err error)

+ func (a *AccessBaseManaVector) GetHighestManaNodes(n uint) (res []Node, t time.Time, err error)

+ func (a *AccessBaseManaVector) GetMana(nodeID identity.ID, optionalUpdateTime ...time.Time) (float64, time.Time, error)

+ func (a *AccessBaseManaVector) GetManaMap(optionalUpdateTime ...time.Time) (res NodeMap, t time.Time, err error)

+ func (a *AccessBaseManaVector) Has(nodeID identity.ID) bool

+ func (a *AccessBaseManaVector) RemoveZeroNodes()

+ func (a *AccessBaseManaVector) SetMana(nodeID identity.ID, bm BaseMana)

+ func (a *AccessBaseManaVector) Size() int

+ func (a *AccessBaseManaVector) ToPersistables() []*PersistableBaseMana

+ func (a *AccessBaseManaVector) Type() Type

+ func (a *AccessBaseManaVector) Update(nodeID identity.ID, t time.Time) error

+ func (a *AccessBaseManaVector) UpdateAll(t time.Time) error

+ type BaseMana interface

+ BaseValue func() float64

+ EffectiveValue func() float64

+ LastUpdate func() time.Time

+ type BaseManaJSON struct

+ BaseMana float64

+ EffectiveBaseMana float64

+ LastUpdated int64

+ type BaseManaVector interface

+ Book func(*TxInfo)

+ ForEach func(func(identity.ID, BaseMana) bool)

+ FromPersistable func(*PersistableBaseMana) error

+ GetHighestManaNodes func(uint) ([]Node, time.Time, error)

+ GetMana func(identity.ID, ...time.Time) (float64, time.Time, error)

+ GetManaMap func(...time.Time) (NodeMap, time.Time, error)

+ Has func(identity.ID) bool

+ RemoveZeroNodes func()

+ SetMana func(identity.ID, BaseMana)

+ Size func() int

+ ToPersistables func() []*PersistableBaseMana

+ Type func() Type

+ Update func(identity.ID, time.Time) error

+ UpdateAll func(time.Time) error

+ func NewBaseManaVector(vectorType Type) (BaseManaVector, error)

+ func NewResearchBaseManaVector(vectorType Type, targetMana Type, weight float64) (BaseManaVector, error)

+ type CachedConsensusBasePastManaVectorMetadata struct

+ func (c *CachedConsensusBasePastManaVectorMetadata) Consume(consumer func(pbm *ConsensusBasePastManaVectorMetadata)) bool

+ func (c *CachedConsensusBasePastManaVectorMetadata) Retain() *CachedConsensusBasePastManaVectorMetadata

+ func (c *CachedConsensusBasePastManaVectorMetadata) Unwrap() *ConsensusBasePastManaVectorMetadata

+ type CachedPersistableBaseMana struct

+ func (cachedPbm *CachedPersistableBaseMana) Consume(consumer func(pbm *PersistableBaseMana)) bool

+ func (cachedPbm *CachedPersistableBaseMana) Retain() *CachedPersistableBaseMana

+ func (cachedPbm *CachedPersistableBaseMana) Unwrap() *PersistableBaseMana

+ type CachedPersistableEvent struct

+ func (c *CachedPersistableEvent) Consume(consumer func(pbm *PersistableEvent)) bool

+ func (c *CachedPersistableEvent) Retain() *CachedPersistableEvent

+ func (c *CachedPersistableEvent) Unwrap() *PersistableEvent

+ type ConsensusBaseMana struct

+ BaseMana1 float64

+ EffectiveBaseMana1 float64

+ LastUpdated time.Time

+ func (c *ConsensusBaseMana) BaseValue() float64

+ func (c *ConsensusBaseMana) EffectiveValue() float64

+ func (c *ConsensusBaseMana) LastUpdate() time.Time

+ type ConsensusBaseManaVector struct

+ func (c *ConsensusBaseManaVector) Book(txInfo *TxInfo)

+ func (c *ConsensusBaseManaVector) BuildPastBaseVector(eventsLog []Event, t time.Time) error

+ func (c *ConsensusBaseManaVector) ForEach(callback func(ID identity.ID, bm BaseMana) bool)

+ func (c *ConsensusBaseManaVector) FromPersistable(p *PersistableBaseMana) (err error)

+ func (c *ConsensusBaseManaVector) GetHighestManaNodes(n uint) (res []Node, t time.Time, err error)

+ func (c *ConsensusBaseManaVector) GetMana(nodeID identity.ID, optionalUpdateTime ...time.Time) (float64, time.Time, error)

+ func (c *ConsensusBaseManaVector) GetManaMap(optionalUpdateTime ...time.Time) (res NodeMap, t time.Time, err error)

+ func (c *ConsensusBaseManaVector) Has(nodeID identity.ID) bool

+ func (c *ConsensusBaseManaVector) RemoveZeroNodes()

+ func (c *ConsensusBaseManaVector) SetMana(nodeID identity.ID, bm BaseMana)

+ func (c *ConsensusBaseManaVector) Size() int

+ func (c *ConsensusBaseManaVector) ToPersistables() []*PersistableBaseMana

+ func (c *ConsensusBaseManaVector) Type() Type

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

+ func (c *ConsensusBaseManaVector) UpdateAll(t time.Time) error

+ type ConsensusBasePastManaVectorMetadata struct

+ Timestamp time.Time

+ func (c *ConsensusBasePastManaVectorMetadata) Bytes() []byte

+ func (c *ConsensusBasePastManaVectorMetadata) ObjectStorageKey() []byte

+ func (c *ConsensusBasePastManaVectorMetadata) ObjectStorageValue() []byte

+ func (c *ConsensusBasePastManaVectorMetadata) Update(other objectstorage.StorableObject)

+ type Event interface

+ Timestamp func() time.Time

+ ToJSONSerializable func() interface{}

+ ToPersistable func() *PersistableEvent

+ Type func() byte

+ func FromPersistableEvent(p *PersistableEvent) (Event, error)

+ type EventDefinitions struct

+ Pledged *events.Event

+ Revoked *events.Event

+ Updated *events.Event

+ func Events() *EventDefinitions

+ type EventSlice []Event

+ func (e EventSlice) Sort()

+ type InputInfo struct

+ Amount float64

+ InputID ledgerstate.OutputID

+ PledgeID map[Type]identity.ID

+ TimeStamp time.Time

+ type Node struct

+ ID identity.ID

+ Mana float64

+ func (n Node) ToNodeStr() NodeStr

+ type NodeMap map[identity.ID]float64

+ func (n NodeMap) GetPercentile(node identity.ID) (float64, error)

+ func (n NodeMap) ToNodeStrList() []NodeStr

+ type NodeMapStr map[string]float64

+ type NodeStr struct

+ Mana float64

+ NodeID string

+ ShortNodeID string

+ type PersistableBaseMana struct

+ BaseValues []float64

+ EffectiveValues []float64

+ LastUpdated time.Time

+ ManaType Type

+ NodeID identity.ID

+ func FromBytes(bytes []byte) (result *PersistableBaseMana, consumedBytes int, err error)

+ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *PersistableBaseMana, err error)

+ func (persistableBaseMana *PersistableBaseMana) Bytes() []byte

+ func (persistableBaseMana *PersistableBaseMana) ObjectStorageKey() []byte

+ func (persistableBaseMana *PersistableBaseMana) ObjectStorageValue() []byte

+ func (persistableBaseMana *PersistableBaseMana) String() string

+ func (persistableBaseMana *PersistableBaseMana) Update(objectstorage.StorableObject)

+ type PersistableEvent struct

+ Amount float64

+ InputID ledgerstate.OutputID

+ ManaType Type

+ NodeID identity.ID

+ Time time.Time

+ TransactionID ledgerstate.TransactionID

+ Type byte

+ func (p *PersistableEvent) Bytes() []byte

+ func (p *PersistableEvent) ObjectStorageKey() []byte

+ func (p *PersistableEvent) ObjectStorageValue() []byte

+ func (p *PersistableEvent) ToStringKeys() []string

+ func (p *PersistableEvent) ToStringValues() []string

+ func (p *PersistableEvent) Update(objectstorage.StorableObject)

+ type PledgedEvent struct

+ Amount float64

+ ManaType Type

+ NodeID identity.ID

+ Time time.Time

+ TransactionID ledgerstate.TransactionID

+ func (p *PledgedEvent) Timestamp() time.Time

+ func (p *PledgedEvent) ToJSONSerializable() interface{}

+ func (p *PledgedEvent) ToPersistable() *PersistableEvent

+ func (p *PledgedEvent) Type() byte

+ type PledgedEventJSON struct

+ Amount float64

+ ManaType string

+ NodeID string

+ Time int64

+ TxID string

+ type RandChoice struct

+ Item interface{}

+ Weight int

+ func NewChoice(item interface{}, weight int) RandChoice

+ type RandChooser struct

+ func NewRandChooser(cs ...RandChoice) *RandChooser

+ func (chs *RandChooser) Pick(n uint) []interface{}

+ type RevokedEvent struct

+ Amount float64

+ InputID ledgerstate.OutputID

+ ManaType Type

+ NodeID identity.ID

+ Time time.Time

+ TransactionID ledgerstate.TransactionID

+ func (r *RevokedEvent) Timestamp() time.Time

+ func (r *RevokedEvent) ToJSONSerializable() interface{}

+ func (r *RevokedEvent) ToPersistable() *PersistableEvent

+ func (r *RevokedEvent) Type() byte

+ type RevokedEventJSON struct

+ Amount float64

+ InputID string

+ ManaType string

+ NodeID string

+ Time int64

+ TxID string

+ type TxInfo struct

+ InputInfos []InputInfo

+ PledgeID map[Type]identity.ID

+ TimeStamp time.Time

+ TotalBalance float64

+ TransactionID ledgerstate.TransactionID

+ type Type byte

+ const AccessMana

+ const ConsensusMana

+ const ResearchAccess

+ const ResearchConsensus

+ const WeightedMana

+ func TypeFromString(stringType string) (Type, error)

+ func (t Type) String() string

+ type UpdatedEvent struct

+ ManaType Type

+ NewMana BaseMana

+ NodeID identity.ID

+ OldMana BaseMana

+ func (u *UpdatedEvent) Timestamp() time.Time

+ func (u *UpdatedEvent) ToJSONSerializable() interface{}

+ func (u *UpdatedEvent) ToPersistable() *PersistableEvent

+ func (u *UpdatedEvent) Type() byte

+ type UpdatedEventJSON struct

+ ManaType string

+ NewMana interface{}

+ NodeID string

+ OldMana interface{}

+ type WeightedBaseMana struct

+ func NewWeightedMana(weight float64) *WeightedBaseMana

+ func (w *WeightedBaseMana) BaseValue() float64

+ func (w *WeightedBaseMana) EffectiveValue() float64

+ func (w *WeightedBaseMana) LastUpdate() time.Time

+ func (w *WeightedBaseMana) SetWeight(weight float64) error

+ type WeightedBaseManaVector struct

+ func (w *WeightedBaseManaVector) Book(txInfo *TxInfo)

+ func (w *WeightedBaseManaVector) ForEach(callback func(ID identity.ID, bm BaseMana) bool)

+ func (w *WeightedBaseManaVector) FromPersistable(p *PersistableBaseMana) (err error)

+ func (w *WeightedBaseManaVector) GetHighestManaNodes(n uint) (res []Node, t time.Time, err error)

+ func (w *WeightedBaseManaVector) GetMana(nodeID identity.ID, optionalUpdateTime ...time.Time) (float64, time.Time, error)

+ func (w *WeightedBaseManaVector) GetManaMap(optionalUpdateTime ...time.Time) (res NodeMap, t time.Time, err error)

+ func (w *WeightedBaseManaVector) Has(nodeID identity.ID) bool

+ func (w *WeightedBaseManaVector) RemoveZeroNodes()

+ func (w *WeightedBaseManaVector) SetMana(nodeID identity.ID, bm BaseMana)

+ func (w *WeightedBaseManaVector) SetMana1(nodeID identity.ID, bm *ConsensusBaseMana)

+ func (w *WeightedBaseManaVector) SetMana2(nodeID identity.ID, bm *AccessBaseMana)

+ func (w *WeightedBaseManaVector) SetWeight(weight float64) error

+ func (w *WeightedBaseManaVector) Size() int

+ func (w *WeightedBaseManaVector) Target() Type

+ func (w *WeightedBaseManaVector) ToPersistables() []*PersistableBaseMana

+ func (w *WeightedBaseManaVector) Type() Type

+ func (w *WeightedBaseManaVector) Update(nodeID identity.ID, t time.Time) error

+ func (w *WeightedBaseManaVector) UpdateAll(t time.Time) error