private void startup() { Log.d(TAG, "startup: "); peerGroup = new PeerGroup(Constants.NETWORK_PARAMETERS, blockChain); peerGroup.setDownloadTxDependencies(0); // recursive implementation causes StackOverflowError peerGroup.addWallet(wallet); try { PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_ACTIVITIES); peerGroup.setUserAgent(USER_AGENT, packageInfo.versionName); } catch (PackageManager.NameNotFoundException e) { e.printStackTrace(); peerGroup.setMaxConnections(8); int connectTimeout = (int) (15 * DateUtils.SECOND_IN_MILLIS); peerGroup.setConnectTimeoutMillis(connectTimeout); int discoveryTimeout = (int) (10 * DateUtils.SECOND_IN_MILLIS); peerGroup.addConnectedEventListener(mPeerConnectedEventListener); peerGroup.addDisconnectedEventListener(mPeerDisconnectedEventListener); peerGroup.addDiscoveredEventListener(mPeerDiscoveredEventListener); peerGroup.setPeerDiscoveryTimeoutMillis(discoveryTimeout); peerGroup.addPeerDiscovery(new PeerDiscovery() { private final PeerDiscovery normalPeerDiscovery = MultiplexingDiscovery .forServices(Constants.NETWORK_PARAMETERS, 0); peerGroup.startAsync(); peerGroup.startBlockChainDownload(null);
/** * Calls {@link PeerGroup#broadcastTransaction(Transaction,int)} with getMinBroadcastConnections() as the number * of connections to wait for before commencing broadcast. */ @Override public TransactionBroadcast broadcastTransaction(final Transaction tx) { return broadcastTransaction(tx, Math.max(1, getMinBroadcastConnections())); }
public static void main(String[] args) throws InterruptedException { BriefLogFormatter.init(); PeerGroup peerGroup = new PeerGroup(PARAMS); peerGroup.setMaxConnections(32); peerGroup.addPeerDiscovery(new DnsDiscovery(PARAMS)); peerGroup.addOnTransactionBroadcastListener(new OnTransactionBroadcastListener() { @Override public void onTransaction(Peer peer, Transaction tx) { Result result = DefaultRiskAnalysis.FACTORY.create(null, tx, NO_DEPS).analyze(); incrementCounter(TOTAL_KEY); log.info("tx {} result {}", tx.getHash(), result); incrementCounter(result.name()); if (result == Result.NON_STANDARD) incrementCounter(Result.NON_STANDARD + "-" + DefaultRiskAnalysis.isStandard(tx)); } }); peerGroup.start(); while (true) { Thread.sleep(STATISTICS_FREQUENCY_MS); printCounters(); } }
@Inject public PeerGroupService(NetworkParameters params, PeerDiscovery peerDiscovery) { this.netParams = params; this.peerGroup = new PeerGroup(params); peerGroup.setUserAgent(userAgentName, appVersion); peerGroup.addPeerDiscovery(peerDiscovery); }
/** * 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. * * @param peerAddress IP/port to use. */ public void addAddress(PeerAddress peerAddress) { int newMax; lock.lock(); try { addInactive(peerAddress); newMax = getMaxConnections() + 1; } finally { lock.unlock(); } setMaxConnections(newMax); }
vPeerGroup = createPeerGroup(); if (this.userAgent != null) vPeerGroup.setUserAgent(userAgent, version); for (PeerAddress addr : peerAddresses) vPeerGroup.addAddress(addr); vPeerGroup.setMaxConnections(peerAddresses.length); peerAddresses = null; } else if (!params.getId().equals(NetworkParameters.ID_REGTEST)) { vPeerGroup.addPeerDiscovery(discovery != null ? discovery : new DnsDiscovery(params)); vPeerGroup.addWallet(vWallet); onSetupCompleted(); vPeerGroup.start(); vPeerGroup.startBlockChainDownload(listener); listener.await(); } else { Futures.addCallback(vPeerGroup.startAsync(), new FutureCallback() { @Override public void onSuccess(@Nullable Object result) {
private void setupNetwork() { params = MainNetParams.get(); peerGroup = new PeerGroup(params, null /* no chain */); peerGroup.setUserAgent("PeerMonitor", "1.0"); peerGroup.setMaxConnections(4); peerGroup.addPeerDiscovery(new DnsDiscovery(params)); peerGroup.addConnectedEventListener(new PeerConnectedEventListener() { @Override public void onPeerConnected(final Peer peer, int peerCount) { refreshUI(); lookupReverseDNS(peer); } }); peerGroup.addDisconnectedEventListener(new PeerDisconnectedEventListener() { @Override public void onPeerDisconnected(final Peer peer, int peerCount) { refreshUI(); synchronized (reverseDnsLookups) { reverseDnsLookups.remove(peer); } } }); }
PeerGroup peers = new PeerGroup(params, chain); peers.addPeerDiscovery(new DnsDiscovery(params)); peers.addWallet(wallet); peers.start(); peers.startBlockChainDownload(bListener); peers.stop();
public void init () { synchronized (initialized) { if (!initialized) { try { blockStore = new SPVBlockStore(Constants.getNetwork(), new File("blockheaders")); } catch (Exception e) { blockStore = new MemoryBlockStore(Constants.getNetwork()); } try { blockChain = new BlockChain(Constants.getNetwork(), blockStore); peerGroup = new PeerGroup(Constants.getNetwork(), blockChain); peerGroup.addPeerDiscovery(new DnsDiscovery(Constants.getNetwork())); peerGroup.setDownloadTxDependencies(false); peerGroup.setBloomFilteringEnabled(false); peerGroup.setFastCatchupTimeSecs(System.currentTimeMillis()); peerGroup.start(); peerGroup.addEventListener(new EventListener(), Threading.SAME_THREAD); registerShutdownHook(); final DownloadProgressTracker listener = new DownloadProgressTracker(); peerGroup.startBlockChainDownload(listener); } catch (Exception e) { throw new RuntimeException(e); } initialized = true; } } }
/** * <p>Create a new peer group</p> * * @param wallet the wallet to add to the peer group after construction * @param useFastCatchup True if only block headers from genesis block is required */ private void createNewPeerGroup(Wallet wallet, boolean useFastCatchup) throws TimeoutException { String[] dnsSeeds = new String[]{ /* "seed.bitcoin.sipa.be", // Pieter Wuille - not reachable */ "dnsseed.bluematt.me", // Matt Corallo "dnsseed.bitcoin.dashjr.org", // Luke Dashjr "seed.bitcoinstats.com", // Chris Decker "seed.bitnodes.io", // Addy Yeow }; log.info("Creating new DNS peer group for '{}'", networkParameters); peerGroup = new PeerGroup(networkParameters, blockChain); peerGroup.addPeerDiscovery(new DnsDiscovery(dnsSeeds, networkParameters)); peerGroup.setConnectTimeoutMillis(CONNECTION_TIMEOUT); peerGroup.setUserAgent( InstallationManager.MBHD_APP_NAME, Configurations.currentConfiguration.getCurrentVersion()); peerGroup.setMaxConnections(MAXIMUM_NUMBER_OF_PEERS); peerGroup.setUseLocalhostPeerWhenPossible(true); peerEventListener = new MultiBitPeerEventListener(); peerGroup.addEventListener(peerEventListener); addWalletToPeerGroup(wallet, useFastCatchup); }
if (options.has("tor")) { try { peers = PeerGroup.newWithTor(params, chain, new TorClient()); } catch (TimeoutException e) { System.err.println("Tor startup timed out, falling back to clear net ..."); peers = new PeerGroup(params, chain); peers.setUserAgent("WalletTool", "1.0"); if (params == RegTestParams.get()) peers.setMinBroadcastConnections(1); peers.addWallet(wallet); if (options.has("peers")) { String peersFlag = (String) options.valueOf("peers"); for (String peer : peerAddrs) { try { peers.addAddress(new PeerAddress(InetAddress.getByName(peer), params.getPort())); } catch (UnknownHostException e) { System.err.println("Could not understand peer domain name/IP address: " + peer + ": " + e.getMessage()); peers.addPeerDiscovery(new DnsDiscovery(params));
public static void main(String[] args) throws Exception { BriefLogFormatter.init(); System.out.println("Connecting to node"); final NetworkParameters params = TestNet3Params.get(); BlockStore blockStore = new MemoryBlockStore(params); BlockChain chain = new BlockChain(params, blockStore); PeerGroup peerGroup = new PeerGroup(params, chain); peerGroup.start(); PeerAddress addr = new PeerAddress(InetAddress.getLocalHost(), params.getPort()); peerGroup.addAddress(addr); peerGroup.waitForPeers(1).get(); Peer peer = peerGroup.getConnectedPeers().get(0); Sha256Hash blockHash = Sha256Hash.wrap(args[0]); Future<Block> future = peer.getBlock(blockHash); System.out.println("Waiting for node to send us the requested block: " + blockHash); Block block = future.get(); System.out.println(block); peerGroup.stopAsync(); } }
public static void main(String[] args) throws Exception { File file = new File(args[0]); Wallet wallet = Wallet.loadFromFile(file); System.out.println(wallet.toString()); // Set up the components and link them together. final NetworkParameters params = TestNet3Params.get(); BlockStore blockStore = new MemoryBlockStore(params); BlockChain chain = new BlockChain(params, wallet, blockStore); final PeerGroup peerGroup = new PeerGroup(params, chain); peerGroup.startAsync(); wallet.addCoinsReceivedEventListener(new WalletCoinsReceivedEventListener() { @Override public synchronized void onCoinsReceived(Wallet w, Transaction tx, Coin prevBalance, Coin newBalance) { System.out.println("\nReceived tx " + tx.getHashAsString()); System.out.println(tx.toString()); } }); // Now download and process the block chain. peerGroup.downloadBlockChain(); peerGroup.stopAsync(); wallet.saveToFile(file); System.out.println("\nDone!\n"); System.out.println(wallet.toString()); } }
peers.start(); peers.broadcastTransaction(req.tx).future().get(); List<Peer> peerList = peers.getConnectedPeers(); if (peerList.size() == 1) peerList.get(0).ping().get();
/** * <p>Adds a listener that will be notified on the given executor when * chain download starts.</p> */ public void addChainDownloadStartedEventListener(Executor executor, ChainDownloadStartedEventListener listener) { peersChainDownloadStartedEventListeners.add(new ListenerRegistration<ChainDownloadStartedEventListener>(checkNotNull(listener), executor)); for (Peer peer : getConnectedPeers()) peer.addChainDownloadStartedEventListener(executor, listener); for (Peer peer : getPendingPeers()) peer.addChainDownloadStartedEventListener(executor, listener); }
/** * * The constructor takes in a NetworkParameters variable that determines whether we * are connecting to the Production Net or the Test Net. It also takes in an int * which determines the minimum number of peers to connect to before broadcasting a transaction. * */ public Bitcoin(NetworkParameters netParams, int minPeers) { this.netParams = netParams; this.minPeers = minPeers; if (minPeers == 0) { peerGroup = null; } else { peerGroup = new PeerGroup(netParams); peerGroup.setMinBroadcastConnections(minPeers); peerGroup.addPeerDiscovery(new DnsDiscovery(netParams)); peerGroup.start(); } this.context = Context.getOrCreate(this.netParams); }
private static void go(Coin feeToTest, int numOutputs) throws InterruptedException, java.util.concurrent.ExecutionException, InsufficientMoneyException { kit.peerGroup().setMaxConnections(25); System.out.println("Size in bytes is " + request.tx.unsafeBitcoinSerialize().length); System.out.println("TX is " + request.tx); System.out.println("Waiting for " + kit.peerGroup().getMaxConnections() + " connected peers"); kit.peerGroup().addDisconnectedEventListener(new PeerDisconnectedEventListener() { @Override public void onPeerDisconnected(Peer peer, int peerCount) { kit.peerGroup().addConnectedEventListener(new PeerConnectedEventListener() { @Override public void onPeerConnected(Peer peer, int peerCount) { kit.peerGroup().broadcastTransaction(request.tx).future().get(); System.out.println("Send complete, waiting for confirmation"); request.tx.getConfidence().getDepthFuture(1).get();
public static void main(String[] args) throws Exception { /* * This is just a test runner that will download blockchain till block * 390000 then exit. */ FullPrunedBlockStore store = new LevelDBFullPrunedBlockStore( MainNetParams.get(), args[0], 1000, 100 * 1024 * 1024l, 10 * 1024 * 1024, 100000, true, 390000); FullPrunedBlockChain vChain = new FullPrunedBlockChain( MainNetParams.get(), store); vChain.setRunScripts(false); PeerGroup vPeerGroup = new PeerGroup(MainNetParams.get(), vChain); vPeerGroup.setUseLocalhostPeerWhenPossible(true); vPeerGroup.addAddress(InetAddress.getLocalHost()); vPeerGroup.start(); vPeerGroup.downloadBlockChain(); } }
bitcoinPeerGroup.setFastCatchupTimeSecs(fastCatchUpInstant.getEpochSecond()); }); bitcoinPeerGroup.start(); Instant.ofEpochSecond(bitcoinPeerGroup.getFastCatchupTimeSecs())); bitcoinPeerGroup.startBlockChainDownload(downloadListener); Instant.ofEpochSecond(bitcoinPeerGroup.getFastCatchupTimeSecs())); LOG.info("Downloading SPV blockchain...");
@Bean public PeerGroup peerGroup(BlockChain bitcoinBlockchain, Context bitcoinContext, NetworkParameters chainNetworkParameters) { PeerGroup peerGroup = new PeerGroup(bitcoinContext, bitcoinBlockchain); // Regtest has no peer-to-peer functionality if (chainNetworkParameters.equals(MainNetParams.get())) { Stream.of(appConfig.getBitcoinNodePeerGroupSeed()) .forEach((peer) -> { try { peerGroup.addAddress(Inet4Address.getByName(peer)); } catch (UnknownHostException e) { LOG.error("Not possible to add peer {} to the peer group. Unknown error: {}", peer, e); } }); } else if (chainNetworkParameters.equals(TestNet3Params.get())) { peerGroup.addPeerDiscovery(new DnsDiscovery(chainNetworkParameters)); } return peerGroup; }