snowstorm

Documentation

Index

• type Consensus
• type Directed
  • func (dg *Directed) Add(tx Tx) error
  • func (dg *Directed) Conflicts(tx Tx) ids.Set
  • func (dg *Directed) Finalized() bool
  • func (dg *Directed) HealthCheck() (interface{}, error)
  • func (dg *Directed) Initialize(ctx *snow.ConsensusContext, params sbcon.Parameters) error
  • func (dg *Directed) IsVirtuous(tx Tx) bool
  • func (dg *Directed) Issued(tx Tx) bool
  • func (dg *Directed) Parameters() sbcon.Parameters
  • func (dg *Directed) Preferences() ids.Set
  • func (dg *Directed) Quiesce() bool
  • func (dg *Directed) RecordPoll(votes ids.Bag) (bool, error)
  • func (dg *Directed) Remove(txID ids.ID) error
  • func (dg *Directed) String() string
  • func (dg *Directed) Virtuous() ids.Set
  • func (dg *Directed) VirtuousVoting() ids.Set
• type DirectedFactory
  • func (DirectedFactory) New() Consensus
• type Factory
• type TestTx
  • func (t *TestTx) Bytes() []byte
  • func (t *TestTx) Dependencies() ([]Tx, error)
  • func (t *TestTx) HasWhitelist() bool
  • func (t *TestTx) InputIDs() []ids.ID
  • func (t *TestTx) Verify() error
  • func (t *TestTx) Whitelist() (ids.Set, error)
• type Tx
• type Whitelister

Types

type Consensus

type Consensus interface {
	fmt.Stringer

	// Takes in the context, alpha, betaVirtuous, and betaRogue
	Initialize(*snow.ConsensusContext, sbcon.Parameters) error

	// Returns the parameters that describe this snowstorm instance
	Parameters() sbcon.Parameters

	// Returns true if transaction <Tx> is virtuous.
	// That is, no transaction has been added that conflicts with <Tx>
	IsVirtuous(Tx) bool

	// Adds a new transaction to vote on. Returns if a critical error has
	// occurred.
	Add(Tx) error

	// Remove a transaction from the set of currently processing txs. It is
	// assumed that the provided transaction ID is currently processing.
	Remove(ids.ID) error

	// Returns true iff transaction <Tx> has been added
	Issued(Tx) bool

	// Returns the set of virtuous transactions
	// that have not yet been accepted or rejected
	Virtuous() ids.Set

	// Returns the currently preferred transactions to be finalized
	Preferences() ids.Set

	// Return the current virtuous transactions that are being voted on.
	VirtuousVoting() ids.Set

	// Returns the set of transactions conflicting with <Tx>
	Conflicts(Tx) ids.Set

	// Collects the results of a network poll. Assumes all transactions
	// have been previously added. Returns true is any statuses or preferences
	// changed. Returns if a critical error has occurred.
	RecordPoll(ids.Bag) (bool, error)

	// Returns true iff all remaining transactions are rogue. Note, it is
	// possible that after returning quiesce, a new decision may be added such
	// that this instance should no longer quiesce.
	Quiesce() bool

	// Returns true iff all added transactions have been finalized. Note, it is
	// possible that after returning finalized, a new decision may be added such
	// that this instance is no longer finalized.
	Finalized() bool

	// HealthCheck returns information about the consensus health.
	HealthCheck() (interface{}, error)
}

Consensus is a snowball instance deciding between an unbounded number of non-transitive conflicts. After performing a network sample of k nodes, you should call collect with the responses.

type Directed

type Directed struct {
	// metrics that describe this consensus instance
	metrics.Latency
	metrics.Polls
	// contains filtered or unexported fields
}

Directed is an implementation of a multi-color, non-transitive, snowball instance

func (*Directed) Add

func (dg *Directed) Add(tx Tx) error

func (*Directed) Conflicts

func (dg *Directed) Conflicts(tx Tx) ids.Set

func (*Directed) Finalized

func (dg *Directed) Finalized() bool

func (*Directed) HealthCheck

func (dg *Directed) HealthCheck() (interface{}, error)

HealthCheck returns information about the consensus health.

func (*Directed) Initialize

func (dg *Directed) Initialize(
	ctx *snow.ConsensusContext,
	params sbcon.Parameters,
) error

func (*Directed) IsVirtuous

func (dg *Directed) IsVirtuous(tx Tx) bool

func (*Directed) Issued

func (dg *Directed) Issued(tx Tx) bool

func (*Directed) Parameters

func (dg *Directed) Parameters() sbcon.Parameters

func (*Directed) Preferences

func (dg *Directed) Preferences() ids.Set

func (*Directed) Quiesce

func (dg *Directed) Quiesce() bool

func (*Directed) RecordPoll

func (dg *Directed) RecordPoll(votes ids.Bag) (bool, error)

func (*Directed) Remove

func (dg *Directed) Remove(txID ids.ID) error

func (*Directed) String

func (dg *Directed) String() string

func (*Directed) Virtuous

func (dg *Directed) Virtuous() ids.Set

func (*Directed) VirtuousVoting

func (dg *Directed) VirtuousVoting() ids.Set

type DirectedFactory

type DirectedFactory struct{}

DirectedFactory implements Factory by returning a directed struct

func (DirectedFactory) New

func (DirectedFactory) New() Consensus

type Factory

type Factory interface {
	New() Consensus
}

Factory returns new instances of Consensus

type TestTx

type TestTx struct {
	choices.TestDecidable

	DependenciesV    []Tx
	DependenciesErrV error
	InputIDsV        []ids.ID
	HasWhitelistV    bool
	WhitelistV       ids.Set
	WhitelistErrV    error
	VerifyV          error
	BytesV           []byte
}

TestTx is a useful test tx

func (*TestTx) Bytes

func (t *TestTx) Bytes() []byte

func (*TestTx) Dependencies

func (t *TestTx) Dependencies() ([]Tx, error)

func (*TestTx) HasWhitelist

func (t *TestTx) HasWhitelist() bool

func (*TestTx) InputIDs

func (t *TestTx) InputIDs() []ids.ID

func (*TestTx) Verify

func (t *TestTx) Verify() error

func (*TestTx) Whitelist

func (t *TestTx) Whitelist() (ids.Set, error)

type Tx

type Tx interface {
	choices.Decidable
	Whitelister

	// Dependencies is a list of transactions upon which this transaction
	// depends. Each element of Dependencies must be verified before Verify is
	// called on this transaction.
	//
	// Similarly, each element of Dependencies must be accepted before this
	// transaction is accepted.
	Dependencies() ([]Tx, error)

	// InputIDs is a set where each element is the ID of a piece of state that
	// will be consumed if this transaction is accepted.
	//
	// In the context of a UTXO-based payments system, for example, this would
	// be the IDs of the UTXOs consumed by this transaction
	InputIDs() []ids.ID

	// Verify that the state transition this transaction would make if it were
	// accepted is valid. If the state transition is invalid, a non-nil error
	// should be returned.
	//
	// It is guaranteed that when Verify is called, all the dependencies of
	// this transaction have already been successfully verified.
	Verify() error

	// Bytes returns the binary representation of this transaction.
	//
	// This is used for sending transactions to peers. Another node should be
	// able to parse these bytes to the same transaction.
	Bytes() []byte
}

Tx consumes state.

type Whitelister

type Whitelister interface {
	// Returns [true] if the underlying instance does implement whitelisted
	// conflicts.
	HasWhitelist() bool

	// Whitelist returns the set of transaction IDs that are explicitly
	// whitelisted. Transactions that are not explicitly whitelisted are
	// considered conflicting.
	Whitelist() (ids.Set, error)
}

Whitelister defines the interface for specifying whitelisted operations.