PeerGroup (bitcoinj-core 0.16-SNAPSHOT API)

java.lang.Object
- org.bitcoinj.core.PeerGroup

All Implemented Interfaces:

TransactionBroadcaster
```
public class PeerGroup
extends java.lang.Object
implements TransactionBroadcaster
```
Runs a set of connections to the P2P network, brings up connections to replace disconnected nodes and manages the interaction between them all. Most applications will want to use one of these.

PeerGroup tries to maintain a constant number of connections to a set of distinct peers. Each peer runs a network listener in its own thread. When a connection is lost, a new peer will be tried after a delay as long as the number of connections less than the maximum.

Connections are made to addresses from a provided list. When that list is exhausted, we start again from the head of the list.

The PeerGroup can broadcast a transaction to the currently connected set of peers. It can also handle download of the blockchain from peers, restarting the process when peers die.

A PeerGroup won't do anything until you call the start() method which will block until peer discovery is completed and some outbound connections have been initiated (it will return before handshaking is done, however). You should call stop() when finished. Note that not all methods of PeerGroup are safe to call from a UI thread as some may do network IO, but starting and stopping the service should be fine.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class PeerGroup.FilterRecalculateMode

Nested Classes
Modifier and Type	Class and Description
`static class`	`PeerGroup.FilterRecalculateMode`

Field Summary

Fields
Modifier and Type	Field and Description
`protected AbstractBlockChain`	`chain`
`static double`	`DEFAULT_BLOOM_FILTER_FP_RATE` The default Bloom filter false positive rate, which is selected to be extremely low such that you hardly ever download false positives.
`static int`	`DEFAULT_CONNECT_TIMEOUT_MILLIS` The default timeout between when a connection attempt begins and version message exchange completes
`static int`	`DEFAULT_CONNECTIONS` The default number of connections to the p2p network the library will try to build.
`static long`	`DEFAULT_PING_INTERVAL_MSEC` How many milliseconds to wait after receiving a pong before sending another ping.
`protected com.google.common.util.concurrent.ListeningScheduledExecutorService`	`executor`
`protected java.util.concurrent.locks.ReentrantLock`	`lock`
`static double`	`MAX_FP_RATE_INCREASE` Maximum increase in FP rate before forced refresh of the bloom filter
`protected NetworkParameters`	`params`
`protected java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerConnectedEventListener>>`	`peerConnectedEventListeners` Callbacks for events related to peers connecting
`protected java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerDisconnectedEventListener>>`	`peerDisconnectedEventListeners` Callbacks for events related to peers disconnecting
`protected java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerDiscoveredEventListener>>`	`peerDiscoveredEventListeners` Callbacks for events related to peer connection/disconnection
`protected java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<OnTransactionBroadcastListener>>`	`peersTransactionBroadastEventListeners`

Constructor Summary

Constructors
Constructor and Description
`PeerGroup(Context context)` Creates a PeerGroup with the given context.
`PeerGroup(Context context, AbstractBlockChain chain)` Creates a PeerGroup for the given context and chain.
`PeerGroup(NetworkParameters params)` See `PeerGroup(Context)`
`PeerGroup(NetworkParameters params, AbstractBlockChain chain)` See `PeerGroup(Context, AbstractBlockChain)`
`PeerGroup(NetworkParameters params, AbstractBlockChain chain, ClientConnectionManager connectionManager)` See `PeerGroup(Context, AbstractBlockChain, ClientConnectionManager)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addAddress(java.net.InetAddress address)` Convenience method for `addAddress(PeerAddress)`.
`void`	`addAddress(java.net.InetAddress address, int priority)` Convenience method for `addAddress(PeerAddress, int)`.
`void`	`addAddress(PeerAddress peerAddress)` Add an address to the list of potential peers to connect to.
`void`	`addAddress(PeerAddress peerAddress, int priority)` Add an address to the list of potential peers to connect to.
`void`	`addBlocksDownloadedEventListener(BlocksDownloadedEventListener listener)` See `Peer.addBlocksDownloadedEventListener(BlocksDownloadedEventListener)`
`void`	`addBlocksDownloadedEventListener(java.util.concurrent.Executor executor, BlocksDownloadedEventListener listener)` Adds a listener that will be notified on the given executor when blocks are downloaded by the download peer.
`void`	`addChainDownloadStartedEventListener(ChainDownloadStartedEventListener listener)` See `Peer.addBlocksDownloadedEventListener(BlocksDownloadedEventListener)`
`void`	`addChainDownloadStartedEventListener(java.util.concurrent.Executor executor, ChainDownloadStartedEventListener listener)` Adds a listener that will be notified on the given executor when chain download starts.
`void`	`addConnectedEventListener(java.util.concurrent.Executor executor, PeerConnectedEventListener listener)` Adds a listener that will be notified on the given executor when new peers are connected to.
`void`	`addConnectedEventListener(PeerConnectedEventListener listener)` See `Peer.addConnectedEventListener(PeerConnectedEventListener)`
`void`	`addDisconnectedEventListener(java.util.concurrent.Executor executor, PeerDisconnectedEventListener listener)` Adds a listener that will be notified on the given executor when peers are disconnected from.
`void`	`addDisconnectedEventListener(PeerDisconnectedEventListener listener)` See `Peer.addDisconnectedEventListener(PeerDisconnectedEventListener)`
`void`	`addDiscoveredEventListener(java.util.concurrent.Executor executor, PeerDiscoveredEventListener listener)` Adds a listener that will be notified on the given executor when new peers are discovered.
`void`	`addDiscoveredEventListener(PeerDiscoveredEventListener listener)` See `addDiscoveredEventListener(Executor, PeerDiscoveredEventListener)`
`void`	`addGetDataEventListener(java.util.concurrent.Executor executor, GetDataEventListener listener)` See `Peer.addGetDataEventListener(Executor, GetDataEventListener)`
`void`	`addGetDataEventListener(GetDataEventListener listener)` See `Peer.addGetDataEventListener(GetDataEventListener)`
`void`	`addOnTransactionBroadcastListener(java.util.concurrent.Executor executor, OnTransactionBroadcastListener listener)` See `Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)`
`void`	`addOnTransactionBroadcastListener(OnTransactionBroadcastListener listener)` See `Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)`
`void`	`addPeerDiscovery(PeerDiscovery peerDiscovery)` Add addresses from a discovery source to the list of potential peers to connect to.
`com.google.common.util.concurrent.ListenableFuture<BloomFilter>`	`addPeerFilterProvider(PeerFilterProvider provider)` Link the given PeerFilterProvider to this PeerGroup.
`void`	`addPreMessageReceivedEventListener(java.util.concurrent.Executor executor, PreMessageReceivedEventListener listener)` See `Peer.addPreMessageReceivedEventListener(Executor, PreMessageReceivedEventListener)`
`void`	`addPreMessageReceivedEventListener(PreMessageReceivedEventListener listener)` See `Peer.addPreMessageReceivedEventListener(PreMessageReceivedEventListener)`
`void`	`addWallet(Wallet wallet)` Link the given wallet to this PeerGroup.
`TransactionBroadcast`	`broadcastTransaction(Transaction tx)` Calls `broadcastTransaction(Transaction, int, boolean)` with getMinBroadcastConnections() as the number of connections to wait for before commencing broadcast.
`TransactionBroadcast`	`broadcastTransaction(Transaction tx, int minConnections, boolean dropPeersAfterBroadcast)` Given a transaction, sends it un-announced to one peer and then waits for it to be received back from other peers.
`Peer`	`connectTo(java.net.InetSocketAddress address)` Connect to a peer by creating a channel to the destination address.
`protected Peer`	`connectTo(PeerAddress address, boolean incrementMaxConnections, int connectTimeoutMillis)` Creates a version message to send, constructs a Peer object and attempts to connect it.
`Peer`	`connectToLocalHost()` Helper for forcing a connection to localhost.
`protected Peer`	`createPeer(PeerAddress address, VersionMessage ver)` You can override this to customise the creation of `Peer` objects.
`protected com.google.common.util.concurrent.ListeningScheduledExecutorService`	`createPrivateExecutor()`
`protected int`	`discoverPeers()` Returns number of discovered peers.
`void`	`downloadBlockChain()` Download the blockchain from peers.
`void`	`dropAllPeers()` Gracefully drops all connected peers.
`java.util.List<Peer>`	`findPeersOfAtLeastVersion(long protocolVersion)` Returns an array list of peers that implement the given protocol version or better.
`java.util.List<Peer>`	`findPeersWithServiceMask(int mask)` Returns an array list of peers that match the requested service bit mask.
`java.util.List<Peer>`	`getConnectedPeers()` Returns a newly allocated list containing the currently connected peers.
`Peer`	`getDownloadPeer()` Returns the currently selected download peer.
`long`	`getFastCatchupTimeSecs()` Returns the current fast catchup time.
`int`	`getMaxConnections()` The maximum number of connections that we will create to peers.
`int`	`getMaxPeersToDiscoverCount()` Returns the maximum number of `Peer`s to discover.
`TxConfidenceTable`	`getMemoryPool()` Deprecated.
`int`	`getMinBroadcastConnections()` Returns the number of connections that are required before transactions will be broadcast.
`int`	`getMinRequiredProtocolVersion()` The minimum protocol version required: defaults to the version required for Bloom filtering.
`int`	`getMostCommonChainHeight()` Returns our peers most commonly reported chain height.
`static int`	`getMostCommonChainHeight(java.util.List<Peer> peers)` Returns most commonly reported chain height from the given list of `Peer`s.
`java.util.List<Peer>`	`getPendingPeers()` Returns a list containing Peers that did not complete connection yet.
`long`	`getPingIntervalMsec()` Returns the period between pings for an individual peer.
`boolean`	`getUseLocalhostPeerWhenPossible()` See `setUseLocalhostPeerWhenPossible(boolean)`
`VersionMessage`	`getVersionMessage()` Returns the version message provided by setVersionMessage or a default if none was given.
`protected void`	`handleNewPeer(Peer peer)`
`protected void`	`handlePeerDeath(Peer peer, java.lang.Throwable exception)`
`boolean`	`isBloomFilteringEnabled()` Returns whether the Bloom filtering protocol optimisation is in use: defaults to true.
`boolean`	`isRunning()`
`int`	`numConnectedPeers()` Returns the number of currently connected peers.
`com.google.common.util.concurrent.ListenableFuture<BloomFilter>`	`recalculateFastCatchupAndFilter(PeerGroup.FilterRecalculateMode mode)` Recalculates the bloom filter given to peers as well as the timestamp after which full blocks are downloaded (instead of only headers).
`boolean`	`removeBlocksDownloadedEventListener(BlocksDownloadedEventListener listener)`
`boolean`	`removeChainDownloadStartedEventListener(ChainDownloadStartedEventListener listener)`
`boolean`	`removeConnectedEventListener(PeerConnectedEventListener listener)` The given event listener will no longer be called with events.
`boolean`	`removeDisconnectedEventListener(PeerDisconnectedEventListener listener)` The given event listener will no longer be called with events.
`boolean`	`removeDiscoveredEventListener(PeerDiscoveredEventListener listener)` The given event listener will no longer be called with events.
`boolean`	`removeGetDataEventListener(GetDataEventListener listener)` The given event listener will no longer be called with events.
`boolean`	`removeOnTransactionBroadcastListener(OnTransactionBroadcastListener listener)` The given event listener will no longer be called with events.
`void`	`removePeerFilterProvider(PeerFilterProvider provider)` Opposite of `addPeerFilterProvider(PeerFilterProvider)`.
`boolean`	`removePreMessageReceivedEventListener(PreMessageReceivedEventListener listener)`
`void`	`removeWallet(Wallet wallet)` Unlinks the given wallet so it no longer receives broadcast transactions or has its transactions announced.
`protected Peer`	`selectDownloadPeer(java.util.List<Peer> peers)` Given a list of Peers, return a Peer to be used as the download peer.
`void`	`setBloomFilterFalsePositiveRate(double bloomFilterFPRate)` Sets the false positive rate of bloom filters given to peers.
`void`	`setBloomFilteringEnabled(boolean bloomFilteringEnabled)` Can be used to disable Bloom filtering entirely, even in SPV mode.
`void`	`setConnectTimeoutMillis(int connectTimeoutMillis)` Sets the timeout between when a connection attempt to a peer begins and when the version message exchange completes.
`void`	`setDownloadTxDependencies(int depth)` Configure download of pending transaction dependencies.
`void`	`setFastCatchupTimeSecs(long secondsSinceEpoch)` Tells the `PeerGroup` to download only block headers before a certain time and bodies after that.
`void`	`setMaxConnections(int maxConnections)` Adjusts the desired number of connections that we will create to peers.
`void`	`setMaxPeersToDiscoverCount(int maxPeersToDiscoverCount)` Sets the maximum number of `Peer`s to discover.
`void`	`setMinBroadcastConnections(int value)` See `getMinBroadcastConnections()`.
`void`	`setMinRequiredProtocolVersion(int minRequiredProtocolVersion)` If a peer is connected to that claims to speak a protocol version lower than the given version, it will be disconnected and another one will be tried instead.
`void`	`setPeerDiscoveryTimeoutMillis(long peerDiscoveryTimeoutMillis)` This is how many milliseconds we wait for peer discoveries to return their results.
`void`	`setPingIntervalMsec(long pingIntervalMsec)` Sets the period between pings for an individual peer.
`void`	`setRequiredServices(long requiredServices)` Convenience for connecting only to peers that can serve specific services.
`void`	`setStallThreshold(int periodSecs, int bytesPerSecond)` Configures the stall speed: the speed at which a peer is considered to be serving us the block chain unacceptably slowly.
`void`	`setUseLocalhostPeerWhenPossible(boolean useLocalhostPeerWhenPossible)` When true (the default), PeerGroup will attempt to connect to a Bitcoin node running on localhost before attempting to use the P2P network.
`void`	`setUserAgent(java.lang.String name, java.lang.String version)` Sets information that identifies this software to remote nodes.
`void`	`setUserAgent(java.lang.String name, java.lang.String version, java.lang.String comments)` Sets information that identifies this software to remote nodes.
`void`	`setVersionMessage(VersionMessage ver)` Sets the `VersionMessage` that will be announced on newly created connections.
`void`	`start()` Does a blocking startup.
`com.google.common.util.concurrent.ListenableFuture`	`startAsync()` Starts the PeerGroup and begins network activity.
`void`	`startBlockChainDownload(PeerDataEventListener listener)` Start downloading the blockchain.
`void`	`stop()` Does a blocking stop
`com.google.common.util.concurrent.ListenableFuture`	`stopAsync()`
`com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>>`	`waitForPeers(int numPeers)` Returns a future that is triggered when the number of connected peers is equal to the given number of peers.
`com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>>`	`waitForPeersOfVersion(int numPeers, long protocolVersion)` Returns a future that is triggered when there are at least the requested number of connected peers that support the given protocol version or higher.
`com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>>`	`waitForPeersWithServiceMask(int numPeers, int mask)` Returns a future that is triggered when there are at least the requested number of connected peers that support the given protocol version or higher.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - lock
```
protected final java.util.concurrent.locks.ReentrantLock lock
```
  - DEFAULT_CONNECTIONS
```
public static final int DEFAULT_CONNECTIONS
```
    The default number of connections to the p2p network the library will try to build. This is set to 12 empirically. It used to be 4, but because we divide the connection pool in two for broadcasting transactions, that meant we were only sending transactions to two peers and sometimes this wasn't reliable enough: transactions wouldn't get through.
    
    See Also:
    
    Constant Field Values
  - params
```
protected final NetworkParameters params
```
  - chain
```
@Nullable
protected final AbstractBlockChain chain
```
  - executor
```
protected final com.google.common.util.concurrent.ListeningScheduledExecutorService executor
```
  - peerConnectedEventListeners
```
protected final java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerConnectedEventListener>> peerConnectedEventListeners
```
    Callbacks for events related to peers connecting
  - peerDiscoveredEventListeners
```
protected final java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerDiscoveredEventListener>> peerDiscoveredEventListeners
```
    Callbacks for events related to peer connection/disconnection
  - peerDisconnectedEventListeners
```
protected final java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<PeerDisconnectedEventListener>> peerDisconnectedEventListeners
```
    Callbacks for events related to peers disconnecting
  - peersTransactionBroadastEventListeners
```
protected final java.util.concurrent.CopyOnWriteArrayList<ListenerRegistration<OnTransactionBroadcastListener>> peersTransactionBroadastEventListeners
```
  - DEFAULT_PING_INTERVAL_MSEC
```
public static final long DEFAULT_PING_INTERVAL_MSEC
```
    How many milliseconds to wait after receiving a pong before sending another ping.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_BLOOM_FILTER_FP_RATE
```
public static final double DEFAULT_BLOOM_FILTER_FP_RATE
```
    The default Bloom filter false positive rate, which is selected to be extremely low such that you hardly ever download false positives. This provides maximum performance. Although this default can be overridden to push the FP rate higher, due to various complexities there are still ways a remote peer can deanonymize the users wallet. This is why the FP rate is chosen for performance rather than privacy. If a future version of bitcoinj fixes the known de-anonymization attacks this FP rate may rise again (or more likely, become expressed as a bandwidth allowance).
    
    See Also:
    
    Constant Field Values
  - MAX_FP_RATE_INCREASE
```
public static final double MAX_FP_RATE_INCREASE
```
    Maximum increase in FP rate before forced refresh of the bloom filter
    
    See Also:
    
    Constant Field Values
  - DEFAULT_CONNECT_TIMEOUT_MILLIS
```
public static final int DEFAULT_CONNECT_TIMEOUT_MILLIS
```
    The default timeout between when a connection attempt begins and version message exchange completes
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PeerGroup
```
public PeerGroup(NetworkParameters params)
```
    See PeerGroup(Context)
  - PeerGroup
```
public PeerGroup(Context context)
```
    Creates a PeerGroup with the given context. No chain is provided so this node will report its chain height as zero to other peers. This constructor is useful if you just want to explore the network but aren't interested in downloading block data.
  - PeerGroup
```
public PeerGroup(NetworkParameters params,
                 @Nullable
                 AbstractBlockChain chain)
```
    See PeerGroup(Context, AbstractBlockChain)
  - PeerGroup
```
public PeerGroup(Context context,
                 @Nullable
                 AbstractBlockChain chain)
```
    Creates a PeerGroup for the given context and chain. Blocks will be passed to the chain as they are broadcast and downloaded. This is probably the constructor you want to use.
  - PeerGroup
```
public PeerGroup(NetworkParameters params,
                 @Nullable
                 AbstractBlockChain chain,
                 ClientConnectionManager connectionManager)
```
    See PeerGroup(Context, AbstractBlockChain, ClientConnectionManager)
- Method Detail
  - createPrivateExecutor
```
protected com.google.common.util.concurrent.ListeningScheduledExecutorService createPrivateExecutor()
```
  - setPeerDiscoveryTimeoutMillis
```
public void setPeerDiscoveryTimeoutMillis(long peerDiscoveryTimeoutMillis)
```
    This is how many milliseconds we wait for peer discoveries to return their results.
  - setMaxConnections
```
public void setMaxConnections(int maxConnections)
```
    Adjusts the desired number of connections that we will create to peers. Note that if there are already peers open and the new value is lower than the current number of peers, those connections will be terminated. Likewise if there aren't enough current connections to meet the new requested max size, some will be added.
  - setDownloadTxDependencies
```
public void setDownloadTxDependencies(int depth)
```
    Configure download of pending transaction dependencies. A change of values only takes effect for newly connected peers.
  - getMaxConnections
```
public int getMaxConnections()
```
    The maximum number of connections that we will create to peers.
  - setVersionMessage
```
public void setVersionMessage(VersionMessage ver)
```
    Sets the VersionMessage that will be announced on newly created connections. A version message is primarily interesting because it lets you customize the "subVer" field which is used a bit like the User-Agent field from HTTP. It means your client tells the other side what it is, see BIP 14. The VersionMessage you provide is copied and the best chain height/time filled in for each new connection, therefore you don't have to worry about setting that. The provided object is really more of a template.
  - getVersionMessage
```
public VersionMessage getVersionMessage()
```
    Returns the version message provided by setVersionMessage or a default if none was given.
  - setUserAgent
```
public void setUserAgent(java.lang.String name,
                         java.lang.String version,
                         @Nullable
                         java.lang.String comments)
```
    Sets information that identifies this software to remote nodes. This is a convenience wrapper for creating a new VersionMessage, calling VersionMessage.appendToSubVer(String, String, String) on it, and then calling setVersionMessage(VersionMessage) on the result of that. See the docs for VersionMessage.appendToSubVer(String, String, String) for information on what the fields should contain.
  - setUserAgent
```
public void setUserAgent(java.lang.String name,
                         java.lang.String version)
```
    Sets information that identifies this software to remote nodes. This is a convenience wrapper for creating a new VersionMessage, calling VersionMessage.appendToSubVer(String, String, String) on it, and then calling setVersionMessage(VersionMessage) on the result of that. See the docs for VersionMessage.appendToSubVer(String, String, String) for information on what the fields should contain.
  - addBlocksDownloadedEventListener
```
public void addBlocksDownloadedEventListener(BlocksDownloadedEventListener listener)
```
    See Peer.addBlocksDownloadedEventListener(BlocksDownloadedEventListener)
  - addBlocksDownloadedEventListener
```
public void addBlocksDownloadedEventListener(java.util.concurrent.Executor executor,
                                             BlocksDownloadedEventListener listener)
```
    Adds a listener that will be notified on the given executor when blocks are downloaded by the download peer.
    
    See Also:
    
    Peer.addBlocksDownloadedEventListener(Executor, BlocksDownloadedEventListener)
  - addChainDownloadStartedEventListener
```
public void addChainDownloadStartedEventListener(ChainDownloadStartedEventListener listener)
```
    See Peer.addBlocksDownloadedEventListener(BlocksDownloadedEventListener)
  - addChainDownloadStartedEventListener
```
public void addChainDownloadStartedEventListener(java.util.concurrent.Executor executor,
                                                 ChainDownloadStartedEventListener listener)
```
    Adds a listener that will be notified on the given executor when chain download starts.
  - addConnectedEventListener
```
public void addConnectedEventListener(PeerConnectedEventListener listener)
```
    See Peer.addConnectedEventListener(PeerConnectedEventListener)
  - addConnectedEventListener
```
public void addConnectedEventListener(java.util.concurrent.Executor executor,
                                      PeerConnectedEventListener listener)
```
    Adds a listener that will be notified on the given executor when new peers are connected to.
  - addDisconnectedEventListener
```
public void addDisconnectedEventListener(PeerDisconnectedEventListener listener)
```
    See Peer.addDisconnectedEventListener(PeerDisconnectedEventListener)
  - addDisconnectedEventListener
```
public void addDisconnectedEventListener(java.util.concurrent.Executor executor,
                                         PeerDisconnectedEventListener listener)
```
    Adds a listener that will be notified on the given executor when peers are disconnected from.
  - addDiscoveredEventListener
```
public void addDiscoveredEventListener(PeerDiscoveredEventListener listener)
```
    See addDiscoveredEventListener(Executor, PeerDiscoveredEventListener)
  - addDiscoveredEventListener
```
public void addDiscoveredEventListener(java.util.concurrent.Executor executor,
                                       PeerDiscoveredEventListener listener)
```
    Adds a listener that will be notified on the given executor when new peers are discovered.
  - addGetDataEventListener
```
public void addGetDataEventListener(GetDataEventListener listener)
```
    See Peer.addGetDataEventListener(GetDataEventListener)
  - addGetDataEventListener
```
public void addGetDataEventListener(java.util.concurrent.Executor executor,
                                    GetDataEventListener listener)
```
    See Peer.addGetDataEventListener(Executor, GetDataEventListener)
  - addOnTransactionBroadcastListener
```
public void addOnTransactionBroadcastListener(OnTransactionBroadcastListener listener)
```
    See Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)
  - addOnTransactionBroadcastListener
```
public void addOnTransactionBroadcastListener(java.util.concurrent.Executor executor,
                                              OnTransactionBroadcastListener listener)
```
    See Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)
  - addPreMessageReceivedEventListener
```
public void addPreMessageReceivedEventListener(PreMessageReceivedEventListener listener)
```
    See Peer.addPreMessageReceivedEventListener(PreMessageReceivedEventListener)
  - addPreMessageReceivedEventListener
```
public void addPreMessageReceivedEventListener(java.util.concurrent.Executor executor,
                                               PreMessageReceivedEventListener listener)
```
    See Peer.addPreMessageReceivedEventListener(Executor, PreMessageReceivedEventListener)
  - removeBlocksDownloadedEventListener
```
public boolean removeBlocksDownloadedEventListener(BlocksDownloadedEventListener listener)
```
  - removeChainDownloadStartedEventListener
```
public boolean removeChainDownloadStartedEventListener(ChainDownloadStartedEventListener listener)
```
  - removeConnectedEventListener
```
public boolean removeConnectedEventListener(PeerConnectedEventListener listener)
```
    The given event listener will no longer be called with events.
  - removeDisconnectedEventListener
```
public boolean removeDisconnectedEventListener(PeerDisconnectedEventListener listener)
```
    The given event listener will no longer be called with events.
  - removeDiscoveredEventListener
```
public boolean removeDiscoveredEventListener(PeerDiscoveredEventListener listener)
```
    The given event listener will no longer be called with events.
  - removeGetDataEventListener
```
public boolean removeGetDataEventListener(GetDataEventListener listener)
```
    The given event listener will no longer be called with events.
  - removeOnTransactionBroadcastListener
```
public boolean removeOnTransactionBroadcastListener(OnTransactionBroadcastListener listener)
```
    The given event listener will no longer be called with events.
  - removePreMessageReceivedEventListener
```
public boolean removePreMessageReceivedEventListener(PreMessageReceivedEventListener listener)
```
  - getConnectedPeers
```
public java.util.List<Peer> getConnectedPeers()
```
    Returns a newly allocated list containing the currently connected peers. If all you care about is the count, use numConnectedPeers().
  - getPendingPeers
```
public java.util.List<Peer> getPendingPeers()
```
    Returns a list containing Peers that did not complete connection yet.
  - addAddress
```
public void addAddress(PeerAddress peerAddress)
```
    Add an address to the list of potential peers to connect to. It won't necessarily be used unless there's a need to build new connections to reach the max connection count.
    
    Parameters:
    
    peerAddress - IP/port to use.
  - addAddress
```
public void addAddress(PeerAddress peerAddress,
                       int priority)
```
    Add an address to the list of potential peers to connect to. It won't necessarily be used unless there's a need to build new connections to reach the max connection count.
    
    Parameters:
    
    peerAddress - IP/port to use.
    
    priority - for connecting and being picked as a download peer
  - setRequiredServices
```
public void setRequiredServices(long requiredServices)
```
    Convenience for connecting only to peers that can serve specific services. It will configure suitable peer discoveries.
    
    Parameters:
    
    requiredServices - Required services as a bitmask, e.g. VersionMessage.NODE_NETWORK.
  - addAddress
```
public void addAddress(java.net.InetAddress address)
```
    Convenience method for addAddress(PeerAddress).
  - addAddress
```
public void addAddress(java.net.InetAddress address,
                       int priority)
```
    Convenience method for addAddress(PeerAddress, int).
  - addPeerDiscovery
```
public void addPeerDiscovery(PeerDiscovery peerDiscovery)
```
    Add addresses from a discovery source to the list of potential peers to connect to. If max connections has not been configured, or set to zero, then it's set to the default at this point.
  - discoverPeers
```
protected int discoverPeers()
```
    Returns number of discovered peers.
  - startAsync
```
public com.google.common.util.concurrent.ListenableFuture startAsync()
```
    Starts the PeerGroup and begins network activity.
    
    Returns:
    
    A future that completes when first connection activity has been triggered (note: not first connection made).
  - start
```
public void start()
```
    Does a blocking startup.
  - stopAsync
```
public com.google.common.util.concurrent.ListenableFuture stopAsync()
```
  - stop
```
public void stop()
```
    Does a blocking stop
  - dropAllPeers
```
public void dropAllPeers()
```
    Gracefully drops all connected peers.
  - addWallet
```
public void addWallet(Wallet wallet)
```
    Link the given wallet to this PeerGroup. This is used for three purposes:
    1. So the wallet receives broadcast transactions.
    2. Announcing pending transactions that didn't get into the chain yet to our peers.
    3. Set the fast catchup time using setFastCatchupTimeSecs(long), to optimize chain download.
    Note that this should be done before chain download commences because if you add a wallet with keys earlier than the current chain head, the relevant parts of the chain won't be redownloaded for you.
    
    The Wallet will have an event listener registered on it, so to avoid leaks remember to use removeWallet(Wallet) on it if you wish to keep the Wallet but lose the PeerGroup.
  - addPeerFilterProvider
```
public com.google.common.util.concurrent.ListenableFuture<BloomFilter> addPeerFilterProvider(PeerFilterProvider provider)
```
    Link the given PeerFilterProvider to this PeerGroup. DO NOT use this for Wallets, use addWallet(Wallet) instead.
    
    Note that this should be done before chain download commences because if you add a listener with keys earlier than the current chain head, the relevant parts of the chain won't be redownloaded for you.
    
    This method invokes recalculateFastCatchupAndFilter(FilterRecalculateMode). The return value of this method is the ListenableFuture returned by that invocation.
    
    Returns:
    
    a future that completes once each Peer in this group has had its BloomFilter (re)set.
  - removePeerFilterProvider
```
public void removePeerFilterProvider(PeerFilterProvider provider)
```
    Opposite of addPeerFilterProvider(PeerFilterProvider). Again, don't use this for wallets. Does not trigger recalculation of the filter.
  - removeWallet
```
public void removeWallet(Wallet wallet)
```
    Unlinks the given wallet so it no longer receives broadcast transactions or has its transactions announced.
  - recalculateFastCatchupAndFilter
```
public com.google.common.util.concurrent.ListenableFuture<BloomFilter> recalculateFastCatchupAndFilter(PeerGroup.FilterRecalculateMode mode)
```
    Recalculates the bloom filter given to peers as well as the timestamp after which full blocks are downloaded (instead of only headers). Note that calls made one after another may return the same future, if the request wasn't processed yet (i.e. calls are deduplicated).
    
    Parameters:
    
    mode - In what situations to send the filter to connected peers.
    
    Returns:
    
    a future that completes once the filter has been calculated (note: this does not mean acknowledged by remote peers).
  - setBloomFilterFalsePositiveRate
```
public void setBloomFilterFalsePositiveRate(double bloomFilterFPRate)
```
    Sets the false positive rate of bloom filters given to peers. The default is DEFAULT_BLOOM_FILTER_FP_RATE.
    
    Be careful regenerating the bloom filter too often, as it decreases anonymity because remote nodes can compare transactions against both the new and old filters to significantly decrease the false positive rate.
    
    See the docs for BloomFilter.BloomFilter(int, double, long, BloomFilter.BloomUpdate) for a brief explanation of anonymity when using bloom filters.
  - numConnectedPeers
```
public int numConnectedPeers()
```
    Returns the number of currently connected peers. To be informed when this count changes, use PeerConnectedEventListener.onPeerConnected(org.bitcoinj.core.Peer, int) and PeerDisconnectedEventListener.onPeerDisconnected(org.bitcoinj.core.Peer, int).
  - connectTo
```
@Nullable
public Peer connectTo(java.net.InetSocketAddress address)
```
    Connect to a peer by creating a channel to the destination address. This should not be used normally - let the PeerGroup manage connections through start()
    
    Parameters:
    
    address - destination IP and port.
    
    Returns:
    
    The newly created Peer object or null if the peer could not be connected. Use Peer.getConnectionOpenFuture() if you want a future which completes when the connection is open.
  - connectToLocalHost
```
@Nullable
public Peer connectToLocalHost()
```
    Helper for forcing a connection to localhost. Useful when using regtest mode. Returns the peer object.
  - connectTo
```
@Nullable
protected Peer connectTo(PeerAddress address,
                                   boolean incrementMaxConnections,
                                   int connectTimeoutMillis)
```
    Creates a version message to send, constructs a Peer object and attempts to connect it. Returns the peer on success or null on failure.
    
    Parameters:
    
    address - Remote network address
    
    incrementMaxConnections - Whether to consider this connection an attempt to fill our quota, or something explicitly requested.
    
    Returns:
    
    Peer or null.
  - createPeer
```
protected Peer createPeer(PeerAddress address,
                          VersionMessage ver)
```
    You can override this to customise the creation of Peer objects.
  - setConnectTimeoutMillis
```
public void setConnectTimeoutMillis(int connectTimeoutMillis)
```
    Sets the timeout between when a connection attempt to a peer begins and when the version message exchange completes. This does not apply to currently pending peers.
  - startBlockChainDownload
```
public void startBlockChainDownload(PeerDataEventListener listener)
```
    Start downloading the blockchain.
    
    If no peers are currently connected, the download will be started once a peer starts. If the peer dies, the download will resume with another peer.
    
    Parameters:
    
    listener - a listener for chain download events, may not be null
  - downloadBlockChain
```
public void downloadBlockChain()
```
    Download the blockchain from peers. Convenience that uses a DownloadProgressTracker for you.
    This method waits until the download is complete. "Complete" is defined as downloading from at least one peer all the blocks that are in that peer's inventory.
  - handleNewPeer
```
protected void handleNewPeer(Peer peer)
```
  - getMemoryPool
```
@Deprecated
 @Nullable
public TxConfidenceTable getMemoryPool()
```
    Deprecated.
    
    Use "Context.get().getConfidenceTable()" instead
  - setFastCatchupTimeSecs
```
public void setFastCatchupTimeSecs(long secondsSinceEpoch)
```
    Tells the PeerGroup to download only block headers before a certain time and bodies after that. Call this before starting block chain download. Do not use a time > NOW - 1 block, as it will break some block download logic.
  - getFastCatchupTimeSecs
```
public long getFastCatchupTimeSecs()
```
    Returns the current fast catchup time. The contents of blocks before this time won't be downloaded as they cannot contain any interesting transactions. If you use addWallet(Wallet) this just returns the min of the wallets earliest key times.
    
    Returns:
    
    a time in seconds since the epoch
  - handlePeerDeath
```
protected void handlePeerDeath(Peer peer,
                               @Nullable
                               java.lang.Throwable exception)
```
  - setStallThreshold
```
public void setStallThreshold(int periodSecs,
                              int bytesPerSecond)
```
    Configures the stall speed: the speed at which a peer is considered to be serving us the block chain unacceptably slowly. Once a peer has served us data slower than the given data rate for the given number of seconds, it is considered stalled and will be disconnected, forcing the chain download to continue from a different peer. The defaults are chosen conservatively, but if you are running on a platform that is CPU constrained or on a very slow network e.g. EDGE, the default settings may need adjustment to avoid false stalls.
    
    Parameters:
    
    periodSecs - How many seconds the download speed must be below blocksPerSec, defaults to 10.
    
    bytesPerSecond - Download speed (only blocks/txns count) must be consistently below this for a stall, defaults to the bandwidth required for 10 block headers per second.
  - waitForPeers
```
public com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>> waitForPeers(int numPeers)
```
    Returns a future that is triggered when the number of connected peers is equal to the given number of peers. By using this with getMaxConnections() you can wait until the network is fully online. To block immediately, just call get() on the result. Just calls waitForPeersOfVersion(int, long) with zero as the protocol version.
    
    Parameters:
    
    numPeers - How many peers to wait for.
    
    Returns:
    
    a future that will be triggered when the number of connected peers is greater than or equals numPeers
  - waitForPeersOfVersion
```
public com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>> waitForPeersOfVersion(int numPeers,
                                                                                                      long protocolVersion)
```
    Returns a future that is triggered when there are at least the requested number of connected peers that support the given protocol version or higher. To block immediately, just call get() on the result.
    
    Parameters:
    
    numPeers - How many peers to wait for.
    
    protocolVersion - The protocol version the awaited peers must implement (or better).
    
    Returns:
    
    a future that will be triggered when the number of connected peers implementing protocolVersion or higher is greater than or equals numPeers
  - findPeersOfAtLeastVersion
```
public java.util.List<Peer> findPeersOfAtLeastVersion(long protocolVersion)
```
    Returns an array list of peers that implement the given protocol version or better.
  - waitForPeersWithServiceMask
```
public com.google.common.util.concurrent.ListenableFuture<java.util.List<Peer>> waitForPeersWithServiceMask(int numPeers,
                                                                                                            int mask)
```
    Returns a future that is triggered when there are at least the requested number of connected peers that support the given protocol version or higher. To block immediately, just call get() on the result.
    
    Parameters:
    
    numPeers - How many peers to wait for.
    
    mask - An integer representing a bit mask that will be ANDed with the peers advertised service masks.
    
    Returns:
    
    a future that will be triggered when the number of connected peers implementing protocolVersion or higher is greater than or equals numPeers
  - findPeersWithServiceMask
```
public java.util.List<Peer> findPeersWithServiceMask(int mask)
```
    Returns an array list of peers that match the requested service bit mask.
  - getMinBroadcastConnections
```
public int getMinBroadcastConnections()
```
    Returns the number of connections that are required before transactions will be broadcast. If there aren't enough, broadcastTransaction(Transaction) will wait until the minimum number is reached so propagation across the network can be observed. If no value has been set using setMinBroadcastConnections(int) a default of 80% of whatever getMaxConnections() returns is used.
  - setMinBroadcastConnections
```
public void setMinBroadcastConnections(int value)
```
    See getMinBroadcastConnections().
  - broadcastTransaction
```
public TransactionBroadcast broadcastTransaction(Transaction tx)
```
    Calls broadcastTransaction(Transaction, int, boolean) with getMinBroadcastConnections() as the number of connections to wait for before commencing broadcast. Also, if the transaction has no broadcast confirmations yet the peers will be dropped after the transaction has been sent.
    
    Specified by:
    
    broadcastTransaction in interface TransactionBroadcaster
  - broadcastTransaction
```
public TransactionBroadcast broadcastTransaction(Transaction tx,
                                                 int minConnections,
                                                 boolean dropPeersAfterBroadcast)
```
    Given a transaction, sends it un-announced to one peer and then waits for it to be received back from other peers. Once all connected peers have announced the transaction, the future available via the TransactionBroadcast.future() method will be completed. If anything goes wrong the exception will be thrown when get() is called, or you can receive it via a callback on the ListenableFuture. This method returns immediately, so if you want it to block just call get() on the result.
    
    Optionally, peers will be dropped after they have been used for broadcasting the transaction and they have no broadcast confirmations yet.
    
    Note that if the PeerGroup is limited to only one connection (discovery is not activated) then the future will complete as soon as the transaction was successfully written to that peer.
    
    The transaction won't be sent until there are at least minConnections active connections available. A good choice for proportion would be between 0.5 and 0.8 but if you want faster transmission during initial bringup of the peer group you can lower it.
    
    The returned TransactionBroadcast object can be used to get progress feedback, which is calculated by watching the transaction propagate across the network and be announced by peers.
  - getPingIntervalMsec
```
public long getPingIntervalMsec()
```
    Returns the period between pings for an individual peer. Setting this lower means more accurate and timely ping times are available via Peer.getLastPingTime() but it increases load on the remote node. It defaults to DEFAULT_PING_INTERVAL_MSEC.
  - setPingIntervalMsec
```
public void setPingIntervalMsec(long pingIntervalMsec)
```
    Sets the period between pings for an individual peer. Setting this lower means more accurate and timely ping times are available via Peer.getLastPingTime() but it increases load on the remote node. It defaults to DEFAULT_PING_INTERVAL_MSEC. Setting the value to be smaller or equals 0 disables pinging entirely, although you can still request one yourself using Peer.ping().
  - setMinRequiredProtocolVersion
```
public void setMinRequiredProtocolVersion(int minRequiredProtocolVersion)
```
    If a peer is connected to that claims to speak a protocol version lower than the given version, it will be disconnected and another one will be tried instead.
  - getMinRequiredProtocolVersion
```
public int getMinRequiredProtocolVersion()
```
    The minimum protocol version required: defaults to the version required for Bloom filtering.
  - getMostCommonChainHeight
```
public int getMostCommonChainHeight()
```
    Returns our peers most commonly reported chain height. If the most common heights are tied, or no peers are connected, returns 0.
  - getMostCommonChainHeight
```
public static int getMostCommonChainHeight(java.util.List<Peer> peers)
```
    Returns most commonly reported chain height from the given list of Peers. If the most common heights are tied, or no peers are connected, returns 0.
  - selectDownloadPeer
```
@Nullable
protected Peer selectDownloadPeer(java.util.List<Peer> peers)
```
    Given a list of Peers, return a Peer to be used as the download peer. If you don't want PeerGroup to manage download peer statuses for you, just override this and always return null.
  - getDownloadPeer
```
public Peer getDownloadPeer()
```
    Returns the currently selected download peer. Bear in mind that it may have changed as soon as this method returns. Can return null if no peer was selected.
  - getMaxPeersToDiscoverCount
```
public int getMaxPeersToDiscoverCount()
```
    Returns the maximum number of Peers to discover. This maximum is checked after each PeerDiscovery so this max number can be surpassed.
    
    Returns:
    
    the maximum number of peers to discover
  - setMaxPeersToDiscoverCount
```
public void setMaxPeersToDiscoverCount(int maxPeersToDiscoverCount)
```
    Sets the maximum number of Peers to discover. This maximum is checked after each PeerDiscovery so this max number can be surpassed.
    
    Parameters:
    
    maxPeersToDiscoverCount - the maximum number of peers to discover
  - getUseLocalhostPeerWhenPossible
```
public boolean getUseLocalhostPeerWhenPossible()
```
    See setUseLocalhostPeerWhenPossible(boolean)
  - setUseLocalhostPeerWhenPossible
```
public void setUseLocalhostPeerWhenPossible(boolean useLocalhostPeerWhenPossible)
```
    When true (the default), PeerGroup will attempt to connect to a Bitcoin node running on localhost before attempting to use the P2P network. If successful, only localhost will be used. This makes for a simple and easy way for a user to upgrade a bitcoinj based app running in SPV mode to fully validating security.
  - isRunning
```
public boolean isRunning()
```
  - setBloomFilteringEnabled
```
public void setBloomFilteringEnabled(boolean bloomFilteringEnabled)
```
    Can be used to disable Bloom filtering entirely, even in SPV mode. You are very unlikely to need this, it is an optimisation for rare cases when full validation is not required but it's still more efficient to download full blocks than filtered blocks.
  - isBloomFilteringEnabled
```
public boolean isBloomFilteringEnabled()
```
    Returns whether the Bloom filtering protocol optimisation is in use: defaults to true.

Class PeerGroup

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

lock

DEFAULT_CONNECTIONS

params

chain

executor

peerConnectedEventListeners

peerDiscoveredEventListeners

peerDisconnectedEventListeners

peersTransactionBroadastEventListeners

DEFAULT_PING_INTERVAL_MSEC

DEFAULT_BLOOM_FILTER_FP_RATE

MAX_FP_RATE_INCREASE

DEFAULT_CONNECT_TIMEOUT_MILLIS

Constructor Detail

PeerGroup

PeerGroup

PeerGroup

PeerGroup

PeerGroup

Method Detail

createPrivateExecutor

setPeerDiscoveryTimeoutMillis

setMaxConnections

setDownloadTxDependencies

getMaxConnections

setVersionMessage

getVersionMessage

setUserAgent

setUserAgent

addBlocksDownloadedEventListener

addBlocksDownloadedEventListener

addChainDownloadStartedEventListener

addChainDownloadStartedEventListener

addConnectedEventListener

addConnectedEventListener

addDisconnectedEventListener

addDisconnectedEventListener

addDiscoveredEventListener

addDiscoveredEventListener

addGetDataEventListener

addGetDataEventListener

addOnTransactionBroadcastListener

addOnTransactionBroadcastListener

addPreMessageReceivedEventListener

addPreMessageReceivedEventListener

removeBlocksDownloadedEventListener

removeChainDownloadStartedEventListener

removeConnectedEventListener

removeDisconnectedEventListener

removeDiscoveredEventListener

removeGetDataEventListener

removeOnTransactionBroadcastListener

removePreMessageReceivedEventListener

getConnectedPeers

getPendingPeers

addAddress

addAddress

setRequiredServices

addAddress

addAddress

addPeerDiscovery

discoverPeers

startAsync

start

stopAsync

stop

dropAllPeers

addWallet

addPeerFilterProvider

removePeerFilterProvider

removeWallet

recalculateFastCatchupAndFilter

setBloomFilterFalsePositiveRate