示例#1
0
        public void CanUseAsyncRPC()
        {
            if (noClient)
            {
                return;
            }

            using (var builder = NodeBuilderPurple.Create())
            {
                CoreNodePurple node = builder.CreateNode();
                RPCClient      rpc  = node.CreateRPCClient();
                builder.StartAll();
                ////node.Generate(10);
                var blkCount = rpc.GetBlockCountAsync().Result;
                Assert.True(blkCount > 10);
            }
        }
示例#2
0
 public CoreNodePurple(string folder, NodeBuilderPurple builder)
 {
     this._Builder = builder;
     this._Folder  = folder;
     //_State = CoreNodeState.Stopped;
     //CleanFolder();
     //Directory.CreateDirectory(folder);
     //dataDir = Path.Combine(folder, "data");
     //Directory.CreateDirectory(dataDir);
     //var pass = Encoders.Hex.EncodeData(RandomUtils.GetBytes(20));
     //creds = new NetworkCredential(pass, pass);
     //_Config = Path.Combine(dataDir, "bitcoin.conf");
     //ConfigParameters.Import(builder.ConfigParameters);
     ports = new int[2];
     FindPorts(ports);
     //ports[1] = Network.PurpleMain.RPCPort;
     //ports[0] = Network.PurpleMain.DefaultPort;
 }
示例#3
0
        public void CanGetBlockFromRPC()
        {
            if (noClient)
            {
                return;
            }

            using (var builder = NodeBuilderPurple.Create())
            {
                RPCClient rpc = builder.CreateNode().CreateRPCClient();
                builder.StartAll();
                BlockHeader response = rpc.GetBlockHeader(0);
                AssertEx.CollectionEquals(Network.PurpleMain.GetGenesis().Header.ToBytes(), response.ToBytes());

                response = rpc.GetBlockHeader(0);
                Assert.Equal(Network.PurpleMain.GenesisHash, response.GetHash());
            }
        }
示例#4
0
        public void CanGetRawMemPool()
        {
            if (noClient)
            {
                return;
            }

            using (var builder = NodeBuilderPurple.Create())
            {
                CoreNodePurple node = builder.CreateNode();
                RPCClient      rpc  = node.CreateRPCClient();
                builder.StartAll();
                ////node.Generate(101);
                //var txid = rpc.SendToAddress(new Key().PubKey.GetAddress(rpc.Network), Money.Coins(1.0m), "hello", "world");
                uint256[] ids = rpc.GetRawMempool();
                Assert.NotNull(ids);
                //Assert.Equal(txid, ids[0]);
            }
        }
示例#5
0
        public void CanAddNodes()
        {
            if (noClient)
            {
                return;
            }

            using (var builder = NodeBuilderPurple.Create())
            {
                CoreNodePurple nodeA = builder.CreateNode();
                CoreNodePurple nodeB = builder.CreateNode();
                builder.StartAll();

                RPCClient rpc = nodeA.CreateRPCClient();
                rpc.RemoveNode(nodeA.Endpoint);
                rpc.AddNode(nodeB.Endpoint);
                Thread.Sleep(500);

                AddedNodeInfo[] info = rpc.GetAddedNodeInfo(true);
                Assert.NotNull(info);
                Assert.NotEmpty(info);

                //For some reason this one does not pass anymore in 0.13.1.
                //Assert.Equal(nodeB.Endpoint, info.First().Addresses.First().Address);
                AddedNodeInfo oneInfo = rpc.GetAddedNodeInfo(true, nodeB.Endpoint);
                Assert.NotNull(oneInfo);
                Assert.True(oneInfo.AddedNode.ToString() == nodeB.Endpoint.ToString());

                oneInfo = rpc.GetAddedNodeInfo(true, nodeA.Endpoint);
                Assert.Null(oneInfo);

                //rpc.RemoveNode(nodeB.Endpoint);
                //Thread.Sleep(500);
                //info = rpc.GetAddedNodeInfo(true);
                //Assert.Equal(0, info.Count());
            }
        }