Package org.bitcoinj.core

Class PeerGroup

java.lang.Object
org.bitcoinj.core.PeerGroup
All Implemented Interfaces:
TransactionBroadcaster
public class PeerGroup extends 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.

  • Field Details

    • lock

      protected final 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:

    • params

      protected final NetworkParameters params

    • chain

      @Nullable protected final AbstractBlockChain chain

    • executor

      protected final com.google.common.util.concurrent.ListeningScheduledExecutorService executor

    • peerConnectedEventListeners

      protected final CopyOnWriteArrayList<ListenerRegistration<PeerConnectedEventListener>> peerConnectedEventListeners
      Callbacks for events related to peers connecting

    • peerDiscoveredEventListeners

      protected final CopyOnWriteArrayList<ListenerRegistration<PeerDiscoveredEventListener>> peerDiscoveredEventListeners
      Callbacks for events related to peer connection/disconnection

    • peerDisconnectedEventListeners

      protected final CopyOnWriteArrayList<ListenerRegistration<PeerDisconnectedEventListener>> peerDisconnectedEventListeners
      Callbacks for events related to peers disconnecting

    • peersTransactionBroadastEventListeners

      protected final 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:

    • 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:

    • 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:

    • 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:

  • Constructor Details

  • Method Details

    • 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(String name, String version, @Nullable 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(String name, 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(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:

    • addChainDownloadStartedEventListener

      public void addChainDownloadStartedEventListener(ChainDownloadStartedEventListener listener)
      See Peer.addBlocksDownloadedEventListener(BlocksDownloadedEventListener)

    • addChainDownloadStartedEventListener

      public void addChainDownloadStartedEventListener(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(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(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(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(Executor executor, GetDataEventListener listener)
      See Peer.addGetDataEventListener(Executor, GetDataEventListener)

    • addOnTransactionBroadcastListener

      public void addOnTransactionBroadcastListener(OnTransactionBroadcastListener listener)
      See Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)

    • addOnTransactionBroadcastListener

      public void addOnTransactionBroadcastListener(Executor executor, OnTransactionBroadcastListener listener)
      See Peer.addOnTransactionBroadcastListener(OnTransactionBroadcastListener)

    • addPreMessageReceivedEventListener

      public void addPreMessageReceivedEventListener(PreMessageReceivedEventListener listener)
      See Peer.addPreMessageReceivedEventListener(PreMessageReceivedEventListener)

    • addPreMessageReceivedEventListener

      public void addPreMessageReceivedEventListener(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 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 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(InetAddress address)
      Convenience method for addAddress(PeerAddress).

    • addAddress

      public void addAddress(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(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(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 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<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<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 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<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 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(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(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.