netsync

package

v0.4.8 Latest Latest Go to latest Published: Sep 12, 2022 License: ISC Imports: 16 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

gitlab.com/jaxnet/jaxnetd

README ¶

netsync

Overview

This package implements a concurrency safe block syncing protocol. The SyncManager communicates with connected peers to perform an initial block download, keep the chain and unconfirmed transaction pool in sync, and announce new blocks connected to the chain. Currently the sync manager selects a single sync peer that it downloads all blocks from until it is up to date with the longest chain the sync peer is aware of.

Installation and Updating

$ go get -u gitlab.com/jaxnet/jaxnetd/netsync

License

Package netsync is licensed under the copyfree ISC License.

Documentation ¶

Overview ¶

Package netsync implements a concurrency safe block syncing protocol. The SyncManager communicates with connected peers to perform an initial block download, keep the chain and unconfirmed transaction pool in sync, and announce new blocks connected to the chain. Currently the sync manager selects a single sync peer that it downloads all blocks from until it is up to date with the longest chain the sync peer is aware of.

Index ¶

func DisableLog()
func UseLogger(logger zerolog.Logger)
type Config
type P2PCom
type P2PConnManager
type PeerNotifier
type RPCSyncMgr
type ServerPeer
type ServerSyncManager
type SyncManager
- func New(config *Config) (*SyncManager, error)

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func DisableLog ¶

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until either UseLogger or SetLogWriter are called.

func UseLogger ¶

func UseLogger(logger zerolog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using btclog.

Types ¶

type Config ¶

type Config struct {
	PeerNotifier PeerNotifier
	Chain        *blockchain.BlockChain
	TxMemPool    *mempool.TxPool
	ChainParams  *chaincfg.Params

	DisableCheckpoints bool
	MaxPeers           int

	FeeEstimator *mempool.FeeEstimator
}

Config is a configuration struct used to initialize a new SyncManager.

type P2PCom ¶

type P2PCom interface {
	RelayTransactions(txns []*mempool.TxDesc)
	AddRebroadcastInventory(iv *wire.InvVect, data interface{})
	BroadcastMessage(msg wire.Message)
	Query(value interface{})
	NetTotals() (uint64, uint64)
	ConnectedCount() int32
}

type P2PConnManager ¶

type P2PConnManager interface {
	// Connect adds the provided address as a new outbound peer.  The
	// permanent flag indicates whether or not to make the peer persistent
	// and reconnect if the connection is lost.  Attempting to connect to an
	// already existing peer will return an error.
	Connect(addr string, permanent bool) error

	// RemoveByID removes the peer associated with the provided id from the
	// list of persistent peers.  Attempting to remove an id that does not
	// exist will return an error.
	RemoveByID(id int32) error

	// RemoveByAddr removes the peer associated with the provided address
	// from the list of persistent peers.  Attempting to remove an address
	// that does not exist will return an error.
	RemoveByAddr(addr string) error

	// DisconnectByID disconnects the peer associated with the provided id.
	// This applies to both inbound and outbound peers.  Attempting to
	// remove an id that does not exist will return an error.
	DisconnectByID(id int32) error

	// DisconnectByAddr disconnects the peer associated with the provided
	// address.  This applies to both inbound and outbound peers.
	// Attempting to remove an address that does not exist will return an
	// error.
	DisconnectByAddr(addr string) error

	// ConnectedCount returns the number of currently connected peers.
	ConnectedCount() int32

	// NetTotals returns the sum of all bytes received and sent across the
	// network for all peers.
	NetTotals() (uint64, uint64)

	// ConnectedPeers returns an array consisting of all connected peers.
	ConnectedPeers() []ServerPeer

	// PersistentPeers returns an array consisting of all the persistent
	// peers.
	PersistentPeers() []ServerPeer

	// BroadcastMessage sends the provided message to all currently
	// connected peers.
	BroadcastMessage(msg wire.Message)

	// AddRebroadcastInventory adds the provided inventory to the list of
	// inventories to be rebroadcast at random intervals until they show up
	// in a block.
	AddRebroadcastInventory(iv *wire.InvVect, data interface{})

	// RelayTransactions generates and relays inventory vectors for all of
	// the passed transactions to all connected peers.
	RelayTransactions(txns []*mempool.TxDesc)
}

P2PConnManager represents a connection manager for use with the RPC server.

The interface contract requires that all of these methods are safe for concurrent access.

type PeerNotifier ¶

type PeerNotifier interface {
	AnnounceNewTransactions(newTxs []*mempool.TxDesc)

	UpdatePeerHeights(latestBlkHash *chainhash.Hash, latestHeight int32, updateSource *peer.Peer)

	RelayInventory(invVect *wire.InvVect, data interface{})

	TransactionConfirmed(tx *jaxutil.Tx)
}

PeerNotifier exposes methods to notify peers of status changes to transactions, blocks, etc. Currently server (in the main package) implements this interface.

type RPCSyncMgr ¶

type RPCSyncMgr struct {
	SyncMgr        *SyncManager
	HeadersLocator func(locators []*chainhash.Hash, hashStop *chainhash.Hash) []wire.BlockHeader
}

RPCSyncMgr provides a block manager for use with the RPC Server and implements the ServerSyncManager interface.

func (*RPCSyncMgr) IsCurrent ¶

func (b *RPCSyncMgr) IsCurrent() bool

IsCurrent returns whether or not the sync manager believes the BlockChain is current as compared to the rest of the network.