indexer

Documentation

Index

• Constants
• type Client
  • func NewClient(uri string) Client
• type Config
• type Container
• type FormattedContainer
• type GetContainerByIDArgs
• type GetContainerByIndexArgs
• type GetContainerRangeArgs
• type GetContainerRangeResponse
• type GetIndexArgs
• type GetIndexResponse
• type GetLastAcceptedArgs
• type Index
• type Indexer
  • func NewIndexer(config Config) (Indexer, error)
• type IsAcceptedArgs
• type IsAcceptedResponse

Constants

const MaxFetchedByRange = 1024

Maximum number of containers IDs that can be fetched at a time in a call to GetContainerRange

Types

type Client

type Client interface {
	// GetContainerRange returns the transactions at index [startIndex], [startIndex+1], ... , [startIndex+n-1]
	// If [n] == 0, returns an empty response (i.e. null).
	// If [startIndex] > the last accepted index, returns an error (unless the above apply.)
	// If we run out of transactions, returns the ones fetched before running out.
	GetContainerRange(ctx context.Context, startIndex uint64, numToFetch int, options ...rpc.Option) ([]Container, error)
	// Get a container by its index
	GetContainerByIndex(ctx context.Context, index uint64, options ...rpc.Option) (Container, error)
	// Get the most recently accepted container and its index
	GetLastAccepted(context.Context, ...rpc.Option) (Container, uint64, error)
	// Returns 1 less than the number of containers accepted on this chain
	GetIndex(ctx context.Context, containerID ids.ID, options ...rpc.Option) (uint64, error)
	// Returns true if the given container is accepted
	IsAccepted(ctx context.Context, containerID ids.ID, options ...rpc.Option) (bool, error)
	// Get a container and its index by its ID
	GetContainerByID(ctx context.Context, containerID ids.ID, options ...rpc.Option) (Container, uint64, error)
}

Client interface for Avalanche Indexer API Endpoint

func NewClient

func NewClient(uri string) Client

NewClient creates a client that can interact with an index via HTTP API calls. [uri] is the path to make API calls to. For example:

• http://1.2.3.4:9650/ext/index/C/block
• http://1.2.3.4:9650/ext/index/X/tx

type Config

type Config struct {
	DB                   database.Database
	Log                  logging.Logger
	IndexingEnabled      bool
	AllowIncompleteIndex bool
	BlockAcceptorGroup   snow.AcceptorGroup
	TxAcceptorGroup      snow.AcceptorGroup
	VertexAcceptorGroup  snow.AcceptorGroup
	APIServer            server.PathAdder
	ShutdownF            func()
}

Config for an indexer

type Container

type Container struct {
	// ID of this container
	ID ids.ID `serialize:"true"`
	// Byte representation of this container
	Bytes []byte `serialize:"true"`
	// Unix time, in nanoseconds, at which this container was accepted by this node
	Timestamp int64 `serialize:"true"`
}

Container is something that gets accepted (a block, transaction or vertex)

type FormattedContainer

type FormattedContainer struct {
	ID        ids.ID              `json:"id"`
	Bytes     string              `json:"bytes"`
	Timestamp time.Time           `json:"timestamp"`
	Encoding  formatting.Encoding `json:"encoding"`
	Index     json.Uint64         `json:"index"`
}

type GetContainerByIDArgs

type GetContainerByIDArgs struct {
	ID       ids.ID              `json:"id"`
	Encoding formatting.Encoding `json:"encoding"`
}

type GetContainerByIndexArgs

type GetContainerByIndexArgs struct {
	Index    json.Uint64         `json:"index"`
	Encoding formatting.Encoding `json:"encoding"`
}

type GetContainerRangeArgs

type GetContainerRangeArgs struct {
	StartIndex json.Uint64         `json:"startIndex"`
	NumToFetch json.Uint64         `json:"numToFetch"`
	Encoding   formatting.Encoding `json:"encoding"`
}

type GetContainerRangeResponse

type GetContainerRangeResponse struct {
	Containers []FormattedContainer `json:"containers"`
}

type GetIndexArgs

type GetIndexArgs struct {
	ID ids.ID `json:"id"`
}

type GetIndexResponse

type GetIndexResponse struct {
	Index json.Uint64 `json:"index"`
}

type GetLastAcceptedArgs

type GetLastAcceptedArgs struct {
	Encoding formatting.Encoding `json:"encoding"`
}

type Index

type Index interface {
	snow.Acceptor
	GetContainerByIndex(index uint64) (Container, error)
	GetContainerRange(startIndex uint64, numToFetch uint64) ([]Container, error)
	GetLastAccepted() (Container, error)
	GetIndex(id ids.ID) (uint64, error)
	GetContainerByID(id ids.ID) (Container, error)
	io.Closer
}

Index indexes containers in their order of acceptance Index is thread-safe. Index assumes that Accept is called before the container is committed to the database of the VM that the container exists in.

type Indexer

type Indexer interface {
	chains.Registrant
	// Close will do nothing and return nil after the first call
	io.Closer
}

Indexer causes accepted containers for a given chain to be indexed by their ID and by the order in which they were accepted by this node. Indexer is threadsafe.

func NewIndexer

func NewIndexer(config Config) (Indexer, error)

NewIndexer returns a new Indexer and registers a new endpoint on the given API server.

type IsAcceptedArgs

type IsAcceptedArgs struct {
	ID ids.ID `json:"id"`
}

type IsAcceptedResponse

type IsAcceptedResponse struct {
	IsAccepted bool `json:"isAccepted"`
}