blockwatch

Documentation

Index

• type Client
• type Config
• type Event
• type EventType
• type GetBlockByNumberResponse
• type RpcClient
  • func NewRpcClient(rpcURL string, requestTimeout time.Duration) (*RpcClient, error)
  • func (rc *RpcClient) FilterLogs(q ethereum.FilterQuery) ([]types.Log, error)
  • func (rc *RpcClient) HeaderByHash(hash common.Hash) (*meshdb.MiniHeader, error)
  • func (rc *RpcClient) HeaderByNumber(number *big.Int) (*meshdb.MiniHeader, error)
• type Stack
  • func NewStack(meshDB *meshdb.MeshDB, limit int) *Stack
  • func (s *Stack) Inspect() ([]*meshdb.MiniHeader, error)
  • func (s *Stack) Peek() (*meshdb.MiniHeader, error)
  • func (s *Stack) Pop() (*meshdb.MiniHeader, error)
  • func (s *Stack) Push(block *meshdb.MiniHeader) error
• type Watcher
  • func New(config Config) *Watcher
  • func (w *Watcher) BackfillEventsIfNeeded(ctx context.Context) error
  • func (w *Watcher) GetLatestBlock() (*meshdb.MiniHeader, error)
  • func (w *Watcher) InspectRetainedBlocks() ([]*meshdb.MiniHeader, error)
  • func (w *Watcher) Subscribe(sink chan<- []*Event) event.Subscription
  • func (w *Watcher) Watch(ctx context.Context) error

Types

type Client

type Client interface {
	HeaderByNumber(number *big.Int) (*meshdb.MiniHeader, error)
	HeaderByHash(hash common.Hash) (*meshdb.MiniHeader, error)
	FilterLogs(q ethereum.FilterQuery) ([]types.Log, error)
}

Client defines the methods needed to satisfy the client expected when instantiating a Watcher instance.

type Config

type Config struct {
	MeshDB              *meshdb.MeshDB
	PollingInterval     time.Duration
	StartBlockDepth     rpc.BlockNumber
	BlockRetentionLimit int
	WithLogs            bool
	Topics              []common.Hash
	Client              Client
}

Config holds some configuration options for an instance of BlockWatcher.

type Event

type Event struct {
	Type        EventType
	BlockHeader *meshdb.MiniHeader
}

Event describes a block event emitted by a Watcher

type EventType

type EventType int

EventType describes the types of events emitted by blockwatch.Watcher. A block can be discovered and added to our representation of the chain. During a block re-org, a block previously stored can be removed from the list.

const (
	Added EventType = iota
	Removed
)

type GetBlockByNumberResponse

type GetBlockByNumberResponse struct {
	Hash       common.Hash `json:"hash"`
	ParentHash common.Hash `json:"parentHash"`
	Number     string      `json:"number"`
}

type RpcClient

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

RpcClient is a Client for fetching Ethereum blocks from a specific JSON-RPC endpoint.

func NewRpcClient

func NewRpcClient(rpcURL string, requestTimeout time.Duration) (*RpcClient, error)

NewRpcClient returns a new Client for fetching Ethereum blocks using the given ethclient.Client.

func (*RpcClient) FilterLogs

func (rc *RpcClient) FilterLogs(q ethereum.FilterQuery) ([]types.Log, error)

FilterLogs returns the logs that satisfy the supplied filter query.

func (*RpcClient) HeaderByHash

func (rc *RpcClient) HeaderByHash(hash common.Hash) (*meshdb.MiniHeader, error)

HeaderByHash fetches a block header by its block hash. If no block exists with this number it will return a `ethereum.NotFound` error.

func (*RpcClient) HeaderByNumber

func (rc *RpcClient) HeaderByNumber(number *big.Int) (*meshdb.MiniHeader, error)

HeaderByNumber fetches a block header by its number. If no `number` is supplied, it will return the latest block header. If no block exists with this number it will return a `ethereum.NotFound` error.

type Stack

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

Stack allows performing basic stack operations on a stack of meshdb.MiniHeaders.

func NewStack

func NewStack(meshDB *meshdb.MeshDB, limit int) *Stack

NewStack instantiates a new stack with the specified size limit. Once the size limit is reached, adding additional blocks will evict the deepest block.

func (*Stack) Inspect

func (s *Stack) Inspect() ([]*meshdb.MiniHeader, error)

Inspect returns all the block headers currently on the stack

func (*Stack) Peek

func (s *Stack) Peek() (*meshdb.MiniHeader, error)

Peek returns the latest block header from the block stack without removing it. It returns nil if the stack is empty.

func (*Stack) Pop

func (s *Stack) Pop() (*meshdb.MiniHeader, error)

Pop removes and returns the latest block header on the block stack. It returns nil if the stack is empty.

func (*Stack) Push

func (s *Stack) Push(block *meshdb.MiniHeader) error

Push pushes a block header onto the block stack. If the stack limit is reached, it will remove the oldest block header.

type Watcher

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

Watcher maintains a consistent representation of the latest `blockRetentionLimit` blocks, handling block re-orgs and network disruptions gracefully. It can be started from any arbitrary block height, and will emit both block added and removed events.

func New

func New(config Config) *Watcher

New creates a new Watcher instance.

func (*Watcher) BackfillEventsIfNeeded

func (w *Watcher) BackfillEventsIfNeeded(ctx context.Context) error

BackfillEventsIfNeeded finds missed events that might have occured while the Mesh node was offline and sends them to event subscribers. It blocks until it is done backfilling or the given context is canceled.

func (*Watcher) GetLatestBlock

func (w *Watcher) GetLatestBlock() (*meshdb.MiniHeader, error)

GetLatestBlock returns the latest block processed

func (*Watcher) InspectRetainedBlocks

func (w *Watcher) InspectRetainedBlocks() ([]*meshdb.MiniHeader, error)

InspectRetainedBlocks returns the blocks retained in-memory by the Watcher instance. It is not particularly performant and therefore should only be used for debugging and testing purposes.

func (*Watcher) Subscribe

func (w *Watcher) Subscribe(sink chan<- []*Event) event.Subscription

Subscribe allows one to subscribe to the block events emitted by the Watcher. To unsubscribe, simply call `Unsubscribe` on the returned subscription. The sink channel should have ample buffer space to avoid blocking other subscribers. Slow subscribers are not dropped.

func (*Watcher) Watch

func (w *Watcher) Watch(ctx context.Context) error

Watch starts the Watcher. It will continuously look for new blocks and blocks until there is a critical error or the given context is canceled. Typically, you want to call Watch inside a goroutine. For non-critical errors, callers must receive them from the Errors channel.