atxsdata

Documentation

Index

• func NotMalicious(d *Data, atx *ATX, _ lockGuard) bool
• func Warmup(db sql.Executor, cache *Data, keep types.EpochID, logger *zap.Logger) error
• type ATX
• type AtxFilter
• type Data
  • func New() *Data
  • func Warm(db sql.StateDatabase, keep types.EpochID, logger *zap.Logger, ...) (*Data, error)
  • func (d *Data) Add(epoch types.EpochID, node types.NodeID, coinbase types.Address, ...) *ATX
  • func (d *Data) AddAtx(target types.EpochID, id types.ATXID, atx *ATX) bool
  • func (d *Data) AddFromAtx(atx *types.ActivationTx, malicious bool) *ATX
  • func (d *Data) EvictEpoch(evict types.EpochID)
  • func (d *Data) Evicted() types.EpochID
  • func (d *Data) Get(epoch types.EpochID, atx types.ATXID) *ATX
  • func (d *Data) GetByEpochAndNodeID(epoch types.EpochID, node types.NodeID) (types.ATXID, *ATX)
  • func (d *Data) IsEvicted(epoch types.EpochID) bool
  • func (d *Data) IsMalicious(node types.NodeID) bool
  • func (d *Data) IterateHighTicksInEpoch(target types.EpochID, fn func(types.ATXID) bool)
  • func (d *Data) IterateInEpoch(epoch types.EpochID, fn func(types.ATXID, *ATX), filters ...AtxFilter)
  • func (d *Data) MaliciousIdentities() []types.NodeID
  • func (d *Data) MissingInEpoch(epoch types.EpochID, atxs []types.ATXID) []types.ATXID
  • func (d *Data) Register(sig *signing.EdSigner)
  • func (d *Data) SetMalicious(node types.NodeID)
  • func (d *Data) Size(target types.EpochID) int
  • func (d *Data) WeightForSet(epoch types.EpochID, set []types.ATXID) (uint64, []bool)

Functions

func NotMalicious

func NotMalicious(d *Data, atx *ATX, _ lockGuard) bool

func Warmup

func Warmup(db sql.Executor, cache *Data, keep types.EpochID, logger *zap.Logger) error

Types

type ATX

type ATX struct {
	Node               types.NodeID
	Coinbase           types.Address
	Weight             uint64
	BaseHeight, Height uint64
	Nonce              types.VRFPostIndex
}

SAFETY: all exported fields are read-only and are safe to read concurrently. Thanks to the fact that ATX is immutable, it is safe to return a pointer to it.

type AtxFilter

type AtxFilter func(*Data, *ATX, lockGuard) bool

AtxFilter is a function that filters atxs. The `lockGuard` prevents using the filter functions outside of the allowed context to prevent data races.

type Data

type Data struct {
	// contains filtered or unexported fields
}

func New

func New() *Data

func Warm

func Warm(db sql.StateDatabase, keep types.EpochID, logger *zap.Logger, signers ...*signing.EdSigner) (*Data, error)

func (*Data) Add

func (d *Data) Add(
	epoch types.EpochID,
	node types.NodeID,
	coinbase types.Address,
	atxid types.ATXID,
	weight, baseHeight, height uint64,
	nonce types.VRFPostIndex,
	malicious bool,
) *ATX

Add adds ATX data to the store. Returns the ATX that was added to the store (if any) or `nil` if it wasn't.

func (*Data) AddAtx

func (d *Data) AddAtx(target types.EpochID, id types.ATXID, atx *ATX) bool

Add adds ATX data to the store. Returns whether the ATX was added to the store.

func (*Data) AddFromAtx

func (d *Data) AddFromAtx(atx *types.ActivationTx, malicious bool) *ATX

AddFromHeader extracts relevant fields from an ActivationTx and adds them together with nonce and malicious flag. Returns the ATX that was added to the store (if any) or `nil` if it wasn't.

func (*Data) EvictEpoch

func (d *Data) EvictEpoch(evict types.EpochID)

EvictEpoch is a notification for cache to evict epochs that are not useful to keep in memory.

func (*Data) Evicted

func (d *Data) Evicted() types.EpochID

func (*Data) Get

func (d *Data) Get(epoch types.EpochID, atx types.ATXID) *ATX

Get returns atx data. SAFETY: The returned pointer MUST NOT be modified.

func (*Data) GetByEpochAndNodeID

func (d *Data) GetByEpochAndNodeID(epoch types.EpochID, node types.NodeID) (types.ATXID, *ATX)

GetByEpochAndNodeID returns atx data by epoch and node id. This query will be slow for nodeIDs that are not managed by the node.

func (*Data) IsEvicted

func (d *Data) IsEvicted(epoch types.EpochID) bool

func (*Data) IsMalicious

func (d *Data) IsMalicious(node types.NodeID) bool

func (*Data) IterateHighTicksInEpoch

func (d *Data) IterateHighTicksInEpoch(target types.EpochID, fn func(types.ATXID) bool)

func (*Data) IterateInEpoch

func (d *Data) IterateInEpoch(epoch types.EpochID, fn func(types.ATXID, *ATX), filters ...AtxFilter)

IterateInEpoch calls `fn` for every ATX in epoch. If filters are provided, only atxs that pass all filters are returned. SAFETY: The returned pointer MUST NOT be modified.

func (*Data) MaliciousIdentities

func (d *Data) MaliciousIdentities() []types.NodeID

func (*Data) MissingInEpoch

func (d *Data) MissingInEpoch(epoch types.EpochID, atxs []types.ATXID) []types.ATXID

func (*Data) Register

func (d *Data) Register(sig *signing.EdSigner)

func (*Data) SetMalicious

func (d *Data) SetMalicious(node types.NodeID)

func (*Data) Size

func (d *Data) Size(target types.EpochID) int

func (*Data) WeightForSet

func (d *Data) WeightForSet(epoch types.EpochID, set []types.ATXID) (uint64, []bool)

WeightForSet computes total weight of atxs in the set and returned array with atxs in the set that weren't used.