vertex

Documentation

Index

• func IsSortedAndUniqueHashOf(bytesSlice [][]byte) bool
• func SortHashOf(bytesSlice [][]byte)
• type Builder
• type DAGVM
• type Heap
  • func NewHeap() Heap
• type Manager
• type Parser
• type StatelessVertex
  • func Build(chainID ids.ID, height uint64, parentIDs []ids.ID, txs [][]byte) (StatelessVertex, error)
  • func Parse(vertex []byte) (StatelessVertex, error)
• type Storage
• type TestBuilder
  • func (b *TestBuilder) BuildVtx(parentIDs []ids.ID, txs []snowstorm.Tx) (avalanche.Vertex, error)
  • func (b *TestBuilder) Default(cant bool)
• type TestManager
  • func NewTestManager(t *testing.T) *TestManager
  • func (m *TestManager) Default(cant bool)
• type TestParser
  • func (p *TestParser) Default(cant bool)
  • func (p *TestParser) ParseVtx(b []byte) (avalanche.Vertex, error)
• type TestStorage
  • func (s *TestStorage) Default(cant bool)
  • func (s *TestStorage) Edge() []ids.ID
  • func (s *TestStorage) GetVtx(id ids.ID) (avalanche.Vertex, error)
• type TestVM
  • func (vm *TestVM) Default(cant bool)
  • func (vm *TestVM) GetTx(txID ids.ID) (snowstorm.Tx, error)
  • func (vm *TestVM) ParseTx(b []byte) (snowstorm.Tx, error)
  • func (vm *TestVM) PendingTxs() []snowstorm.Tx

Functions

func IsSortedAndUniqueHashOf

func IsSortedAndUniqueHashOf(bytesSlice [][]byte) bool

func SortHashOf

func SortHashOf(bytesSlice [][]byte)

Types

type Builder

type Builder interface {
	// Build a new vertex from the contents of a vertex
	BuildVtx(
		parentIDs []ids.ID,
		txs []snowstorm.Tx,
	) (avalanche.Vertex, error)
}

Builder builds a vertex given a set of parentIDs and transactions.

type DAGVM

type DAGVM interface {
	common.VM

	// Return any transactions that have not been sent to consensus yet
	PendingTxs() []snowstorm.Tx

	// Convert a stream of bytes to a transaction or return an error
	ParseTx(tx []byte) (snowstorm.Tx, error)

	// Retrieve a transaction that was submitted previously
	GetTx(ids.ID) (snowstorm.Tx, error)
}

DAGVM defines the minimum functionality that an avalanche VM must implement

type Heap

type Heap interface {
	// Empty the heap.
	Clear()

	// Add the provided vertex to the heap. Vertices are de-duplicated, returns
	// true if the vertex was added, false if it was dropped.
	Push(avalanche.Vertex) bool

	// Remove the top vertex. Assumes that there is at least one element.
	Pop() avalanche.Vertex

	// Returns if a vertex with the provided ID is currently in the heap.
	Contains(ids.ID) bool

	// Returns the number of vertices in the heap.
	Len() int
}

Heap defines the functionality of a heap of vertices with unique VertexIDs ordered by height

func NewHeap

func NewHeap() Heap

NewHeap returns an empty Heap

type Manager

type Manager interface {
	Builder
	Parser
	Storage
}

Manager defines all the vertex related functionality that is required by the consensus engine.

type Parser

type Parser interface {
	// Parse a vertex from a slice of bytes
	ParseVtx(vertex []byte) (avalanche.Vertex, error)
}

Parser parses bytes into a vertex.

type StatelessVertex

type StatelessVertex interface {
	verify.Verifiable
	ID() ids.ID
	Bytes() []byte

	Version() uint16
	ChainID() ids.ID
	Height() uint64
	Epoch() uint32
	ParentIDs() []ids.ID
	Txs() [][]byte
}

func Build

func Build(
	chainID ids.ID,
	height uint64,
	parentIDs []ids.ID,
	txs [][]byte,
) (StatelessVertex, error)

Build a new stateless vertex from the contents of a vertex

func Parse

func Parse(vertex []byte) (StatelessVertex, error)

Parse the provided vertex bytes into a stateless vertex

type Storage

type Storage interface {
	// Get a vertex by its hash from storage.
	GetVtx(vtxID ids.ID) (avalanche.Vertex, error)

	// Edge returns a list of accepted vertex IDs with no accepted children.
	Edge() (vtxIDs []ids.ID)
}

Storage defines the persistent storage that is required by the consensus engine.

type TestBuilder

type TestBuilder struct {
	T            *testing.T
	CantBuildVtx bool
	BuildVtxF    func(
		parentIDs []ids.ID,
		txs []snowstorm.Tx,
	) (avalanche.Vertex, error)
}

func (*TestBuilder) BuildVtx

func (b *TestBuilder) BuildVtx(
	parentIDs []ids.ID,
	txs []snowstorm.Tx,
) (avalanche.Vertex, error)

func (*TestBuilder) Default

func (b *TestBuilder) Default(cant bool)

type TestManager

type TestManager struct {
	TestBuilder
	TestParser
	TestStorage
}

func NewTestManager

func NewTestManager(t *testing.T) *TestManager

func (*TestManager) Default

func (m *TestManager) Default(cant bool)

type TestParser

type TestParser struct {
	T            *testing.T
	CantParseVtx bool
	ParseVtxF    func([]byte) (avalanche.Vertex, error)
}

func (*TestParser) Default

func (p *TestParser) Default(cant bool)

func (*TestParser) ParseVtx

func (p *TestParser) ParseVtx(b []byte) (avalanche.Vertex, error)

type TestStorage

type TestStorage struct {
	T                    *testing.T
	CantGetVtx, CantEdge bool
	GetVtxF              func(ids.ID) (avalanche.Vertex, error)
	EdgeF                func() []ids.ID
}

func (*TestStorage) Default

func (s *TestStorage) Default(cant bool)

func (*TestStorage) Edge

func (s *TestStorage) Edge() []ids.ID

func (*TestStorage) GetVtx

func (s *TestStorage) GetVtx(id ids.ID) (avalanche.Vertex, error)

type TestVM

type TestVM struct {
	common.TestVM

	CantPendingTxs, CantParse, CantGet bool

	PendingTxsF func() []snowstorm.Tx
	ParseTxF    func([]byte) (snowstorm.Tx, error)
	GetTxF      func(ids.ID) (snowstorm.Tx, error)
}

func (*TestVM) Default

func (vm *TestVM) Default(cant bool)

func (*TestVM) GetTx

func (vm *TestVM) GetTx(txID ids.ID) (snowstorm.Tx, error)

func (*TestVM) ParseTx

func (vm *TestVM) ParseTx(b []byte) (snowstorm.Tx, error)

func (*TestVM) PendingTxs

func (vm *TestVM) PendingTxs() []snowstorm.Tx