public void CanGetTransactionsFromMemPool() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(); node.ConfigParameters.Add("whitelist", "127.0.0.1"); node.Start(); var rpc = node.CreateRPCClient(); rpc.Generate(101); rpc.SendCommand("sendtoaddress", new Key().PubKey.GetAddress(Network.RegTest).ToString(), "1.0"); var client = node.CreateNodeClient(); client.VersionHandshake(); var transactions = client.GetMempoolTransactions(); Assert.True(transactions.Length == 1); } }
public void CanDownloadHeaders() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true).CreateNodeClient(); builder.Nodes[0].Generate(50); node.VersionHandshake(); var begin = node.Counter.Snapshot(); var result = node.GetChain(); var end = node.Counter.Snapshot(); var diff = end - begin; Assert.True(node.PeerVersion.StartHeight <= result.Height); var subChain = node.GetChain(result.GetBlock(10).HashBlock); Assert.Equal(10, subChain.Height); } }
public void CanDownloadBlock() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true).CreateNodeClient(); node.VersionHandshake(); node.SendMessageAsync(new GetDataPayload(new InventoryVector { Hash = Network.RegTest.GenesisHash, Type = InventoryType.MSG_BLOCK })); var block = node.ReceiveMessage <BlockPayload>(); Assert.True(block.Object.CheckMerkleRoot()); } }
public void CanSyncWithPoW() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(); builder.StartAll(); node.Generate(100); var nodeClient = node.CreateNodeClient(); nodeClient.VersionHandshake(); var chain = new ConcurrentChain(builder.Network); nodeClient.SynchronizeChain(chain, new SynchronizeChainOptions { SkipPoWCheck = false }); Assert.Equal(100, chain.Height); } }
public void CanDownloadBlocks() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true).CreateNodeClient(); builder.Nodes[0].Generate(50); var chain = node.GetChain(); chain.SetTip(chain.GetBlock(9)); var blocks = node.GetBlocks(chain.ToEnumerable(true).Select(c => c.HashBlock)).ToList(); foreach (var block in blocks) { Assert.True(block.CheckMerkleRoot()); } Assert.Equal(10, blocks.Count); } }
public void CanGetChainsConcurrenty() { using (var builder = NodeBuilderEx.Create()) { var generating = true; var node = builder.CreateNode(true); var rpc = node.CreateRPCClient(); Task.Run(() => { rpc.Generate(600); generating = false; }); var nodeClient = node.CreateNodeClient(); nodeClient._pollHeaderDelay = TimeSpan.FromSeconds(2); nodeClient.VersionHandshake(); var rand = new Random(); Thread.Sleep(1000); var chains = Enumerable.Range(0, 5) .Select(_ => Task.Factory.StartNew(() => { Thread.Sleep(rand.Next(0, 1000)); return(nodeClient.GetChain()); })) .Select(t => t.Result) .ToArray(); while (generating) { SyncAll(nodeClient, rand, chains); } SyncAll(nodeClient, rand, chains); foreach (var c in chains) { Assert.Equal(600, c.Height); } var chainNoHeader = nodeClient.GetChain(new SynchronizeChainOptions { SkipPoWCheck = true, StripHeaders = true }); Assert.False(chainNoHeader.Tip.HasHeader); } }
public void CanGetBlocksWithProtocol() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true); var rpc = node.CreateRPCClient(); rpc.Generate(50); var client = node.CreateNodeClient(); var chain = client.GetChain(); var blocks = client.GetBlocks(chain.GetBlock(20).HashBlock).ToArray(); Assert.Equal(20, blocks.Length); Assert.Equal(chain.GetBlock(20).HashBlock, blocks.Last().Header.GetHash()); blocks = client.GetBlocksFromFork(chain.GetBlock(45)).ToArray(); Assert.Equal(5, blocks.Length); Assert.Equal(chain.GetBlock(50).HashBlock, blocks.Last().Header.GetHash()); Assert.Equal(chain.GetBlock(46).HashBlock, blocks.First().Header.GetHash()); } }
public void SynchronizeChainSurviveReorg() { using (var builder = NodeBuilderEx.Create()) { var chain = new ConcurrentChain(Network.RegTest); var node1 = builder.CreateNode(true); node1.Generate(10); node1.CreateNodeClient().SynchronizeChain(chain); Assert.Equal(10, chain.Height); var node2 = builder.CreateNode(true); node2.Generate(12); var node2c = node2.CreateNodeClient(); node2c._pollHeaderDelay = TimeSpan.FromSeconds(2); node2c.SynchronizeChain(chain); Assert.Equal(12, chain.Height); } }
public void CanGetMemPool() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(); var rpc = node.CreateRPCClient(); node.ConfigParameters.Add("whitelist", "127.0.0.1"); node.Start(); rpc.Generate(102); for (var i = 0; i < 2; i++) { node.CreateRPCClient().SendCommand("sendtoaddress", new Key().PubKey.GetAddress(Network.RegTest).ToString(), "1.0"); } var client = node.CreateNodeClient(); var txIds = client.GetMempool(); Assert.True(txIds.Length == 2); } }
public void CanCancelConnection() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true); var cts = new CancellationTokenSource(); cts.Cancel(); try { var client = Node.Connect(Network.RegTest, "127.0.0.1:" + node.ProtocolPort, new NodeConnectionParameters { ConnectCancellation = cts.Token }); Assert.False(true, "Should have thrown"); } catch (OperationCanceledException) { } } }
public void CanMaintainChainWithChainBehavior() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true).CreateNodeClient(); builder.Nodes[0].Generate(600); var rpc = builder.Nodes[0].CreateRPCClient(); var chain = node.GetChain(rpc.GetBlockHash(500)); Assert.True(chain.Height == 500); using (var tester = new NodeServerTester()) { var n1 = tester.Node1; n1.Behaviors.Add(new ChainBehavior(chain)); n1.VersionHandshake(); Assert.True(n1.MyVersion.StartHeight == 500); var n2 = tester.Node2; Assert.True(n2.MyVersion.StartHeight == 0); Assert.True(n2.PeerVersion.StartHeight == 500); Assert.True(n1.State == NodeState.HandShaked); Assert.True(n2.State == NodeState.HandShaked); var behavior = new ChainBehavior(new ConcurrentChain(Network.RegTest)); n2.Behaviors.Add(behavior); TestUtils.Eventually(() => behavior.Chain.Height == 500); var chain2 = n2.GetChain(rpc.GetBlockHash(500)); Assert.True(chain2.Height == 500); var chain1 = n1.GetChain(rpc.GetBlockHash(500)); Assert.True(chain1.Height == 500); chain1 = n1.GetChain(rpc.GetBlockHash(499)); Assert.True(chain1.Height == 499); //Should not broadcast above HighestValidatorPoW n1.Behaviors.Find <ChainBehavior>().SharedState.HighestValidatedPoW = chain1.GetBlock(300); chain1 = n2.GetChain(rpc.GetBlockHash(499)); Assert.True(chain1.Height == 300); } } }
public void CanDownloadLastBlocks() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true).CreateNodeClient(); builder.Nodes[0].Generate(150); var chain = node.GetChain(); Assert.True(node.PeerVersion.StartHeight <= chain.Height); var subChain = chain.ToEnumerable(true).Take(100).Select(s => s.HashBlock).ToArray(); var begin = node.Counter.Snapshot(); var blocks = node.GetBlocks(subChain).Select(_ => 1).ToList(); var end = node.Counter.Snapshot(); var diff = end - begin; Assert.True(diff.Start == begin.Taken); Assert.True(diff.Taken == end.Taken); Assert.True(diff.TotalBytesRead == end.TotalBytesRead - begin.TotalBytesRead); Assert.True(diff.TotalBytesWritten == end.TotalBytesWritten - begin.TotalBytesWritten); Assert.True(blocks.Count == 100); } }
public void CanGetMerkleRoot() { using (var builder = NodeBuilderEx.Create()) { var node = builder.CreateNode(true); var rpc = node.CreateRPCClient(); var nodeClient = node.CreateNodeClient(); rpc.Generate(101); var knownAddresses = new List <TxDestination>(); var batch = rpc.PrepareBatch(); for (var i = 0; i < 20; i++) { var address = new Key().PubKey.GetAddress(rpc.Network); knownAddresses.Add(address.Hash); #pragma warning disable CS4014 batch.SendCommandAsync("sendtoaddress", address.ToString(), "0.5"); #pragma warning restore CS4014 } batch.SendBatch(); knownAddresses = knownAddresses.Take(10).ToList(); var blockId = rpc.Generate(1)[0]; var block = rpc.GetBlock(blockId); Assert.Equal(21, block.Transactions.Count); var knownTx = block.Transactions[1].GetHash(); nodeClient.VersionHandshake(); using (var list = nodeClient.CreateListener() .Where(m => m.Message.Payload is MerkleBlockPayload || m.Message.Payload is TxPayload)) { var filter = new BloomFilter(1, 0.0001, 50, BloomFlags.UPDATE_NONE); foreach (var a in knownAddresses) { filter.Insert(a.ToBytes()); } nodeClient.SendMessageAsync(new FilterLoadPayload(filter)); nodeClient.SendMessageAsync( new GetDataPayload(new InventoryVector(InventoryType.MSG_FILTERED_BLOCK, block.GetHash()))); var merkle = list.ReceivePayload <MerkleBlockPayload>(); var tree = merkle.Object.PartialMerkleTree; Assert.True(tree.Check(block.Header.HashMerkleRoot)); Assert.True(tree.GetMatchedTransactions().Count() >= 10); Assert.True(tree.GetMatchedTransactions().Contains(knownTx)); var matched = new List <Transaction>(); for (var i = 0; i < tree.GetMatchedTransactions().Count(); i++) { matched.Add(list.ReceivePayload <TxPayload>().Object); } Assert.True(matched.Count >= 10); tree = tree.Trim(knownTx); Assert.True(tree.GetMatchedTransactions().Count() == 1); Assert.True(tree.GetMatchedTransactions().Contains(knownTx)); Action act = () => { foreach (var match in matched) { Assert.True(filter.IsRelevantAndUpdate(match)); } }; act(); filter = filter.Clone(); act(); var unknownBlock = uint256.Parse("00000000ad262227291eaf90cafdc56a8f8451e2d7653843122c5bb0bf2dfcdd"); nodeClient.SendMessageAsync(new GetDataPayload(new InventoryVector(InventoryType.MSG_FILTERED_BLOCK, Network.RegTest.GetGenesis().GetHash()))); merkle = list.ReceivePayload <MerkleBlockPayload>(); tree = merkle.Object.PartialMerkleTree; Assert.True(tree.Check(merkle.Object.Header.HashMerkleRoot)); Assert.True(!tree.GetMatchedTransactions().Contains(knownTx)); } } }