private static void syncChain() { try { setup(); int startTransactions = wallet.getTransactions(true).size(); DownloadProgressTracker listener = new DownloadProgressTracker(); peers.start(); peers.startBlockChainDownload(listener); try { listener.await(); } catch (InterruptedException e) { System.err.println("Chain download interrupted, quitting ..."); System.exit(1); } int endTransactions = wallet.getTransactions(true).size(); if (endTransactions > startTransactions) { System.out.println("Synced " + (endTransactions - startTransactions) + " transactions."); } } catch (BlockStoreException e) { System.err.println("Error reading block chain file " + chainFileName + ": " + e.getMessage()); e.printStackTrace(); } }
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(); peerGroup.addAddress(new PeerAddress(InetAddress.getLocalHost(), params.getPort())); peerGroup.waitForPeers(1).get(); Peer peer = peerGroup.getConnectedPeers().get(0); Sha256Hash txHash = Sha256Hash.wrap(args[0]); ListenableFuture<Transaction> future = peer.getPeerMempoolTransaction(txHash); System.out.println("Waiting for node to send us the requested transaction: " + txHash); Transaction tx = future.get(); System.out.println(tx); System.out.println("Waiting for node to send us the dependencies ..."); List<Transaction> deps = peer.downloadDependencies(tx).get(); for (Transaction dep : deps) { System.out.println("Got dependency " + dep.getHashAsString()); } System.out.println("Done."); peerGroup.stop(); } }
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 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; } } }
/** * * 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); }
@Test public void peerDiscoveryPolling() throws InterruptedException { // Check that if peer discovery fails, we keep trying until we have some nodes to talk with. final CountDownLatch latch = new CountDownLatch(1); final AtomicBoolean result = new AtomicBoolean(); peerGroup.addPeerDiscovery(new PeerDiscovery() { @Override public InetSocketAddress[] getPeers(long services, long unused, TimeUnit unused2) throws PeerDiscoveryException { if (!result.getAndSet(true)) { // Pretend we are not connected to the internet. throw new PeerDiscoveryException("test failure"); } else { // Return a bogus address. latch.countDown(); return new InetSocketAddress[]{new InetSocketAddress("localhost", 1)}; } } @Override public void shutdown() { } }); peerGroup.start(); latch.await(); // Check that we did indeed throw an exception. If we got here it means we threw and then PeerGroup tried // again a bit later. assertTrue(result.get()); }
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(); } }
@Override @Before public void setUp() throws Exception { Utils.setMockClock(); // Use mock clock super.setUp(); // Fix the random permutation that TransactionBroadcast uses to shuffle the peers. TransactionBroadcast.random = new Random(0); peerGroup.setMinBroadcastConnections(2); peerGroup.start(); }
private static void rotate() throws BlockStoreException { setup(); peers.start(); // Set a key rotation time and possibly broadcast the resulting maintenance transactions. long rotationTimeSecs = Utils.currentTimeSeconds(); if (options.has(dateFlag)) { rotationTimeSecs = options.valueOf(dateFlag).getTime() / 1000; } else if (options.has(unixtimeFlag)) { rotationTimeSecs = options.valueOf(unixtimeFlag); } log.info("Setting wallet key rotation time to {}", rotationTimeSecs); wallet.setKeyRotationTime(rotationTimeSecs); KeyParameter aesKey = null; if (wallet.isEncrypted()) { aesKey = passwordToKey(true); if (aesKey == null) return; } Futures.getUnchecked(wallet.doMaintenance(aesKey, true)); }
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(); } }
@Test public void preferLocalPeer() throws IOException { // Because we are using the same port (8333 or 18333) that is used by Bitcoin Core // We have to consider 2 cases: // 1. Test are executed on the same machine that is running a full node // 2. Test are executed without any full node running locally // We have to avoid to connecting to real and external services in unit tests // So we skip this test in case we have already something running on port PARAMS.getPort() // Check that if we have a localhost port 8333 or 18333 then it's used instead of the p2p network. ServerSocket local = null; try { local = new ServerSocket(PARAMS.getPort(), 100, InetAddresses.forString("127.0.0.1")); } catch(BindException e) { // Port already in use, skipping this test. return; } try { peerGroup.setUseLocalhostPeerWhenPossible(true); peerGroup.start(); local.accept().close(); // Probe connect local.accept(); // Real connect // If we get here it used the local peer. Check no others are in use. assertEquals(1, peerGroup.getMaxConnections()); assertEquals(PeerAddress.localhost(PARAMS), peerGroup.getPendingPeers().get(0).getAddress()); } finally { local.close(); } }
@Test public void noPings() throws Exception { peerGroup.start(); peerGroup.setPingIntervalMsec(0); VersionMessage versionMessage = new VersionMessage(PARAMS, 2); versionMessage.clientVersion = NetworkParameters.ProtocolVersion.BLOOM_FILTER.getBitcoinProtocolVersion(); versionMessage.localServices = VersionMessage.NODE_NETWORK; connectPeer(1, versionMessage); peerGroup.waitForPeers(1).get(); assertFalse(peerGroup.getConnectedPeers().get(0).getLastPingTime() < Long.MAX_VALUE); }
@Test public void listener() throws Exception { peerGroup.addConnectedEventListener(connectedListener); peerGroup.addDisconnectedEventListener(disconnectedListener); peerGroup.addPreMessageReceivedEventListener(preMessageReceivedListener); peerGroup.start(); // Create a couple of peers. InboundMessageQueuer p1 = connectPeer(1); InboundMessageQueuer p2 = connectPeer(2); connectedPeers.take(); connectedPeers.take(); pingAndWait(p1); pingAndWait(p2); Threading.waitForUserCode(); assertEquals(0, disconnectedPeers.size()); p1.close(); disconnectedPeers.take(); assertEquals(0, disconnectedPeers.size()); p2.close(); disconnectedPeers.take(); assertEquals(0, disconnectedPeers.size()); assertTrue(peerGroup.removeConnectedEventListener(connectedListener)); assertFalse(peerGroup.removeConnectedEventListener(connectedListener)); assertTrue(peerGroup.removeDisconnectedEventListener(disconnectedListener)); assertFalse(peerGroup.removeDisconnectedEventListener(disconnectedListener)); assertTrue(peerGroup.removePreMessageReceivedEventListener(preMessageReceivedListener)); assertFalse(peerGroup.removePreMessageReceivedEventListener(preMessageReceivedListener)); }
@Test public void waitForNumPeers1() throws Exception { ListenableFuture<List<Peer>> future = peerGroup.waitForPeers(3); peerGroup.start(); assertFalse(future.isDone()); connectPeer(1); assertFalse(future.isDone()); connectPeer(2); assertFalse(future.isDone()); assertTrue(peerGroup.waitForPeers(2).isDone()); // Immediate completion. connectPeer(3); future.get(); assertTrue(future.isDone()); }
@Test public void pings() throws Exception { peerGroup.start(); peerGroup.setPingIntervalMsec(100); VersionMessage versionMessage = new VersionMessage(PARAMS, 2); versionMessage.clientVersion = NetworkParameters.ProtocolVersion.BLOOM_FILTER.getBitcoinProtocolVersion(); versionMessage.localServices = VersionMessage.NODE_NETWORK; InboundMessageQueuer p1 = connectPeer(1, versionMessage); Ping ping = (Ping) waitForOutbound(p1); inbound(p1, new Pong(ping.getNonce())); pingAndWait(p1); assertTrue(peerGroup.getConnectedPeers().get(0).getLastPingTime() < Long.MAX_VALUE); // The call to outbound should block until a ping arrives. ping = (Ping) waitForOutbound(p1); inbound(p1, new Pong(ping.getNonce())); assertTrue(peerGroup.getConnectedPeers().get(0).getLastPingTime() < Long.MAX_VALUE); }
@Test public void waitForPeersWithServiceFlags() throws Exception { ListenableFuture<List<Peer>> future = peerGroup.waitForPeersWithServiceMask(2, 3); VersionMessage ver1 = new VersionMessage(PARAMS, 10); ver1.clientVersion = 70000; ver1.localServices = VersionMessage.NODE_NETWORK; VersionMessage ver2 = new VersionMessage(PARAMS, 10); ver2.clientVersion = 70000; ver2.localServices = VersionMessage.NODE_NETWORK | 2; peerGroup.start(); assertFalse(future.isDone()); connectPeer(1, ver1); assertTrue(peerGroup.findPeersWithServiceMask(3).isEmpty()); assertFalse(future.isDone()); connectPeer(2, ver2); assertFalse(future.isDone()); assertEquals(1, peerGroup.findPeersWithServiceMask(3).size()); assertTrue(peerGroup.waitForPeersWithServiceMask(1, 0x3).isDone()); // Immediate completion. connectPeer(3, ver2); future.get(); assertTrue(future.isDone()); peerGroup.stop(); }
@Test public void multiplePeerDiscovery() throws InterruptedException { peerGroup.setMaxPeersToDiscoverCount(98); peerGroup.addPeerDiscovery(createPeerDiscovery(1, 0)); peerGroup.addPeerDiscovery(createPeerDiscovery(2, 100)); peerGroup.addPeerDiscovery(createPeerDiscovery(96, 200)); peerGroup.addPeerDiscovery(createPeerDiscovery(3, 300)); peerGroup.addPeerDiscovery(createPeerDiscovery(1, 400)); peerGroup.addDiscoveredEventListener(new PeerDiscoveredEventListener() { @Override public void onPeersDiscovered(Set<PeerAddress> peerAddresses) { assertEquals(99, peerAddresses.size()); } }); peerGroup.start(); }
@Test public void waitForPeersOfVersion() throws Exception { final int baseVer = peerGroup.getMinRequiredProtocolVersion() + 3000; final int newVer = baseVer + 1000; ListenableFuture<List<Peer>> future = peerGroup.waitForPeersOfVersion(2, newVer); VersionMessage ver1 = new VersionMessage(PARAMS, 10); ver1.clientVersion = baseVer; ver1.localServices = VersionMessage.NODE_NETWORK; VersionMessage ver2 = new VersionMessage(PARAMS, 10); ver2.clientVersion = newVer; ver2.localServices = VersionMessage.NODE_NETWORK; peerGroup.start(); assertFalse(future.isDone()); connectPeer(1, ver1); assertFalse(future.isDone()); connectPeer(2, ver2); assertFalse(future.isDone()); assertTrue(peerGroup.waitForPeersOfVersion(1, newVer).isDone()); // Immediate completion. connectPeer(3, ver2); future.get(); assertTrue(future.isDone()); }
@Test public void receiveTxBroadcastOnAddedWallet() throws Exception { // Check that when we receive transactions on all our peers, we do the right thing. peerGroup.start(); // Create a peer. InboundMessageQueuer p1 = connectPeer(1); Wallet wallet2 = new Wallet(PARAMS); ECKey key2 = wallet2.freshReceiveKey(); Address address2 = key2.toAddress(PARAMS); peerGroup.addWallet(wallet2); blockChain.addWallet(wallet2); assertEquals(BloomFilter.class, waitForOutbound(p1).getClass()); assertEquals(MemoryPoolMessage.class, waitForOutbound(p1).getClass()); Coin value = COIN; Transaction t1 = FakeTxBuilder.createFakeTx(PARAMS, value, address2); InventoryMessage inv = new InventoryMessage(PARAMS); inv.addTransaction(t1); inbound(p1, inv); assertTrue(outbound(p1) instanceof GetDataMessage); inbound(p1, t1); // Asks for dependency. GetDataMessage getdata = (GetDataMessage) outbound(p1); assertNotNull(getdata); inbound(p1, new NotFoundMessage(PARAMS, getdata.getItems())); pingAndWait(p1); assertEquals(value, wallet2.getBalance(Wallet.BalanceType.ESTIMATED)); }
@Test public void testWalletCatchupTime() throws Exception { // Check the fast catchup time was initialized to something around the current runtime minus a week. // The wallet was already added to the peer in setup. final int WEEK = 86400 * 7; final long now = Utils.currentTimeSeconds(); peerGroup.start(); assertTrue(peerGroup.getFastCatchupTimeSecs() > now - WEEK - 10000); Wallet w2 = new Wallet(PARAMS); ECKey key1 = new ECKey(); key1.setCreationTimeSeconds(now - 86400); // One day ago. w2.importKey(key1); peerGroup.addWallet(w2); peerGroup.waitForJobQueue(); assertEquals(peerGroup.getFastCatchupTimeSecs(), now - 86400 - WEEK); // Adding a key to the wallet should update the fast catchup time, but asynchronously and in the background // due to the need to avoid complicated lock inversions. ECKey key2 = new ECKey(); key2.setCreationTimeSeconds(now - 100000); w2.importKey(key2); peerGroup.waitForJobQueue(); assertEquals(peerGroup.getFastCatchupTimeSecs(), now - WEEK - 100000); }