burrow: github.com/hyperledger/burrow/acm/validator Index | Files

package validator

import "github.com/hyperledger/burrow/acm/validator"

Index

Package Files

bucket.go cache.go ring.go set.go validator.go validator.pb.go validators.go

func Add Uses

func Add(vs ReaderWriter, vsOther Iterable) error

Adds vsOther to vs

func AddPower Uses

func AddPower(vs ReaderWriter, id crypto.PublicKey, power *big.Int) error

func Subtract Uses

func Subtract(vs ReaderWriter, vsOther Iterable) error

Subtracts vsOther from vs

func SubtractPower Uses

func SubtractPower(vs ReaderWriter, id crypto.PublicKey, power *big.Int) error

func Write Uses

func Write(vs Writer, vsOther Iterable) error

type Bucket Uses

type Bucket struct {
    // Delta tracks the changes to validator power made since the previous rotation
    Delta *Set
    // Previous the value for all validator powers at the point of the last rotation
    // (the sum of all the deltas over all rotations) - these are the history of the complete validator sets at each rotation
    Previous *Set
    // Tracks the current working version of the next set; Previous + Delta
    Next *Set
    // Flow tracks the absolute value of all flows (difference between previous cum bucket and current delta) towards and away from each validator (tracking each validator separately to avoid double counting flows made against the same validator
    Flow *Set
}

func NewBucket Uses

func NewBucket(initialSets ...Iterable) *Bucket

func (*Bucket) CurrentSet Uses

func (vc *Bucket) CurrentSet() *Set

func (*Bucket) Equal Uses

func (vc *Bucket) Equal(vwOther *Bucket) error

func (*Bucket) Power Uses

func (vc *Bucket) Power(id crypto.Address) (*big.Int, error)

Implement Reader

func (*Bucket) SetPower Uses

func (vc *Bucket) SetPower(id crypto.PublicKey, power *big.Int) (*big.Int, error)

SetPower ensures that validator power would not change too quickly in a single block

func (*Bucket) String Uses

func (vc *Bucket) String() string

type Cache Uses

type Cache struct {
    *Bucket
}

Cache is just a Ring with no memory

func NewCache Uses

func NewCache(backend Iterable) *Cache

func (*Cache) Reset Uses

func (vc *Cache) Reset(backend Iterable)

func (*Cache) Sync Uses

func (vc *Cache) Sync(output Writer) error

type History Uses

type History interface {
    ValidatorChanges(blocksAgo int) IterableReader
    Validators(blocksAgo int) IterableReader
}

type Iterable Uses

type Iterable interface {
    IterateValidators(func(id crypto.Addressable, power *big.Int) error) error
}

type IterableReader Uses

type IterableReader interface {
    Reader
    Iterable
}

type IterableReaderWriter Uses

type IterableReaderWriter interface {
    ReaderWriter
    Iterable
}

type Reader Uses

type Reader interface {
    Power(id crypto.Address) (*big.Int, error)
}

type ReaderWriter Uses

type ReaderWriter interface {
    Reader
    Writer
}

type Ring Uses

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

Ring stores the validator power history in buckets as a riNng buffer. The primary storage is a the difference between each rotation (commit - i.e. block) in 'delta' and the cumulative result of each delta in cum, where the result of the delta at i is stored in the cum at i+1. For example suppose we have 4 buckets then graphically:

delta [d1| d2 | d3 | d4 ] cum [v0|v0+d1|v0+d1+d2 |v0+d1+d2+d3 ]

After the fourth rotation we loop back to the 0th bucket (with [pwer

delta [d5 | d6| d7 | d8 ] cum [v0+d1+d2+d3+d4|...| | ]

func NewRing Uses

func NewRing(initialSet Iterable, windowSize int) *Ring

NewRing provides a sliding window over the last size buckets of validator power changes

func (*Ring) CumulativePower Uses

func (vc *Ring) CumulativePower() *Set

CumulativePower gets the sum of all powers added in any bucket

func (*Ring) CurrentSet Uses

func (vc *Ring) CurrentSet() *Set

func (*Ring) Equal Uses

func (vc *Ring) Equal(vcOther *Ring) error

func (*Ring) GetPower Uses

func (vc *Ring) GetPower(id crypto.Address) *big.Int

func (*Ring) Head Uses

func (vc *Ring) Head() *Bucket

Get the current accumulator bucket

func (*Ring) Next Uses

func (vc *Ring) Next() *Bucket

func (*Ring) OrderedBuckets Uses

func (vc *Ring) OrderedBuckets() []*Bucket

Returns buckets in order head, previous, ...

func (*Ring) Power Uses

func (vc *Ring) Power(id crypto.Address) (*big.Int, error)

Power gets the balance at index from the delta bucket then falling through to the cumulative

func (*Ring) PreviousDelta Uses

func (vc *Ring) PreviousDelta(delay int) *Set

func (*Ring) PreviousSet Uses

func (vc *Ring) PreviousSet(delay int) *Set

func (*Ring) ReIndex Uses

func (vc *Ring) ReIndex(newHead int)

func (*Ring) Rotate Uses

func (vc *Ring) Rotate() (totalPowerChange *big.Int, totalFlow *big.Int, err error)

Rotate the current head bucket to the next bucket and returns the change in total power between the previous bucket and the current head, and the total flow which is the sum of absolute values of all changes each validator's power after rotation the next head is a copy of the current head

func (*Ring) SetPower Uses

func (vc *Ring) SetPower(id crypto.PublicKey, power *big.Int) (*big.Int, error)

func (*Ring) Size Uses

func (vc *Ring) Size() int

Get the number of buckets in the ring (use Current().Count() to get the current number of validators)

func (*Ring) String Uses

func (vc *Ring) String() string

func (*Ring) ValidatorChanges Uses

func (vc *Ring) ValidatorChanges(blocksAgo int) IterableReader

func (*Ring) Validators Uses

func (vc *Ring) Validators(blocksAgo int) IterableReader

type Set Uses

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

A Validator multiset - can be used to capture the global state of validators or as an accumulator each block

func Copy Uses

func Copy(vss ...Iterable) *Set

Copy each of iterable in vss into a new Set - note any iterations errors thrown by the iterable itself will be swallowed Use Write instead if source iterables may error

func CopyTrim Uses

func CopyTrim(vss ...Iterable) *Set

func Diff Uses

func Diff(before, after IterableReader) (*Set, error)

Returns the asymmetric difference, diff, between two Sets such that applying diff to before results in after

func NewSet Uses

func NewSet() *Set

Create a new Validators which can act as an accumulator for validator power changes

func NewTrimSet Uses

func NewTrimSet() *Set

Like Set but removes entries when power is set to 0 this make Count() == CountNonZero() and prevents a set from leaking but does mean that a zero will not be iterated over when performing an update which is necessary in Ring

func UnpersistSet Uses

func UnpersistSet(pvs []*Validator) *Set

func (*Set) ChangePower Uses

func (vs *Set) ChangePower(id crypto.PublicKey, power *big.Int) *big.Int

Add the power of a validator and returns the flow into that validator

func (*Set) CountNonZero Uses

func (vs *Set) CountNonZero() int

func (*Set) Equal Uses

func (vs *Set) Equal(vsOther *Set) error

Returns an error if the Sets are not equal describing which part of their structures differ

func (*Set) Flow Uses

func (vs *Set) Flow(id crypto.PublicKey, power *big.Int) *big.Int

Returns the flow that would be induced by a validator power change

func (*Set) Flush Uses

func (vs *Set) Flush(output Writer, backend Reader) error

func (*Set) GetPower Uses

func (vs *Set) GetPower(id crypto.Address) *big.Int

Error free version of Power

func (*Set) IterateValidators Uses

func (vs *Set) IterateValidators(iter func(id crypto.Addressable, power *big.Int) error) error

Iterates over validators sorted by address

func (*Set) MaxFlow Uses

func (vs *Set) MaxFlow() *big.Int

Returns the maximum allowable flow whilst ensuring the majority of validators are non-byzantine after the transition So need at most ceiling((Total Power)/3) - 1, in integer division we have ceiling(X*p/q) = (p(X+1)-1)/q For p = 1 just X/q so we want (Total Power)/3 - 1

func (*Set) MaybePower Uses

func (vs *Set) MaybePower(id crypto.Address) *big.Int

Returns the power of id but only if it is set

func (*Set) Power Uses

func (vs *Set) Power(id crypto.Address) (*big.Int, error)

Version of Power to match interface

func (*Set) SetPower Uses

func (vs *Set) SetPower(id crypto.PublicKey, power *big.Int) (*big.Int, error)

Implements Writer, but will never error

func (*Set) Size Uses

func (vs *Set) Size() int

func (*Set) String Uses

func (vs *Set) String() string

func (*Set) Strings Uses

func (vs *Set) Strings() string

func (*Set) TotalPower Uses

func (vs *Set) TotalPower() *big.Int

func (*Set) Validators Uses

func (vs *Set) Validators() []*Validator

type Validator Uses

type Validator struct {
    Address              *github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address,omitempty"`
    PublicKey            crypto.PublicKey                              `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey"`
    Power                uint64                                        `protobuf:"varint,3,opt,name=Power,proto3" json:"Power,omitempty"`
    XXX_NoUnkeyedLiteral struct{}                                      `json:"-"`
    XXX_unrecognized     []byte                                        `json:"-"`
    XXX_sizecache        int32                                         `json:"-"`
}

func FromAccount Uses

func FromAccount(acc *acm.Account, power uint64) *Validator

func New Uses

func New(publicKey crypto.PublicKey, power *big.Int) *Validator

func (*Validator) BigPower Uses

func (v *Validator) BigPower() *big.Int

func (*Validator) Descriptor Uses

func (*Validator) Descriptor() ([]byte, []int)

func (*Validator) FillAddress Uses

func (v *Validator) FillAddress()

func (*Validator) GetAddress Uses

func (v *Validator) GetAddress() crypto.Address

func (*Validator) GetPower Uses

func (m *Validator) GetPower() uint64

func (*Validator) GetPublicKey Uses

func (m *Validator) GetPublicKey() crypto.PublicKey

func (*Validator) ProtoMessage Uses

func (*Validator) ProtoMessage()

func (*Validator) Reset Uses

func (m *Validator) Reset()

func (*Validator) Size Uses

func (m *Validator) Size() (n int)

func (*Validator) String Uses

func (v *Validator) String() string

func (*Validator) XXX_DiscardUnknown Uses

func (m *Validator) XXX_DiscardUnknown()

func (*Validator) XXX_Marshal Uses

func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Validator) XXX_Merge Uses

func (m *Validator) XXX_Merge(src proto.Message)

func (*Validator) XXX_MessageName Uses

func (*Validator) XXX_MessageName() string

func (*Validator) XXX_Size Uses

func (m *Validator) XXX_Size() int

func (*Validator) XXX_Unmarshal Uses

func (m *Validator) XXX_Unmarshal(b []byte) error

type Writer Uses

type Writer interface {
    SetPower(id crypto.PublicKey, power *big.Int) (flow *big.Int, err error)
}

Package validator imports 12 packages (graph) and is imported by 36 packages. Updated 2020-04-30. Refresh now. Tools for package owners.