public void Import(NodeConfigParameters configParameters)
 {
     foreach (var kv in configParameters)
     {
         if (!this.ContainsKey(kv.Key))
         {
             this.Add(kv.Key, kv.Value);
         }
     }
 }
        public NodeBuilder(string root, string bitcoindPath)
        {
            this.last             = 0;
            this.Nodes            = new List <CoreNode>();
            this.ConfigParameters = new NodeConfigParameters();
            this.disposables      = new List <IDisposable>();

            this.root     = root;
            this.BitcoinD = bitcoindPath;
        }
        public void PremineNodeWithWalletWithOverrides()
        {
            var configParameters = new NodeConfigParameters {
                { "savetrxhex", "true" }
            };

            var callback = new Action <IFullNodeBuilder>(builder => builder
                                                         .UseBlockStore()
                                                         .UsePosConsensus()
                                                         .UseMempool()
                                                         .UseWallet()
                                                         .AddPowPosMining()
                                                         .AddRPC()
                                                         .MockIBD()
                                                         .OverrideDateTimeProviderFor <MiningFeature>());

            this.PremineNodeWithCoins = this.nodeBuilder.CreateCustomNode(callback, new StratisRegTest(), ProtocolVersion.PROTOCOL_VERSION, configParameters: configParameters);
            this.PremineNodeWithCoins.WithWallet().Start();
        }
Exemplo n.º 4
0
        public void CanOverrideAllPorts()
        {
            // On MacOS ports below 1024 are privileged, and cannot be bound to by anyone other than root.
            const int port    = 1024 + 123;
            const int rpcPort = 1024 + 456;
            const int apiPort = 1024 + 567;

            var extraParams = new NodeConfigParameters
            {
                { "port", port.ToString() },
                { "rpcport", rpcPort.ToString() },
                { "apiport", apiPort.ToString() }
            };

            using (var nodeBuilder = NodeBuilder.Create(this))
            {
                var buildAction = new Action <IFullNodeBuilder>(builder =>
                                                                builder.UseBlockStore()
                                                                .UsePowConsensus()
                                                                .UseMempool()
                                                                .AddMining()
                                                                .UseWallet()
                                                                .AddRPC()
                                                                .UseApi()
                                                                .MockIBD());

                var coreNode = nodeBuilder.CreateCustomNode(buildAction, this.network,
                                                            ProtocolVersion.PROVEN_HEADER_VERSION, configParameters: extraParams);

                coreNode.Start();

                coreNode.ApiPort.Should().Be(apiPort);
                coreNode.FullNode.NodeService <ApiSettings>().ApiPort.Should().Be(apiPort);

                coreNode.RpcPort.Should().Be(rpcPort);
                coreNode.FullNode.NodeService <RpcSettings>().RPCPort.Should().Be(rpcPort);

                coreNode.ProtocolPort.Should().Be(port);
                coreNode.FullNode.ConnectionManager.ConnectionSettings.ExternalEndpoint.Port.Should().Be(port);
            }
        }
        public async Task StartAsync()
        {
            NodeConfigParameters config = new NodeConfigParameters();

            config.Add("regtest", "1");
            config.Add("rest", "1");
            config.Add("server", "1");
            config.Add("txindex", "1");
            config.Add("rpcuser", this.creds.UserName);
            config.Add("rpcpassword", this.creds.Password);
            config.Add("port", this.ports[0].ToString());
            config.Add("rpcport", this.ports[1].ToString());
            config.Add("printtoconsole", "1");
            config.Add("keypool", "10");
            config.Import(this.ConfigParameters);
            File.WriteAllText(this.config, config.ToString());
            lock (this.lockObject)
            {
                this.runner.Start(this.dataDir);
                this.state = CoreNodeState.Starting;
            }
            while (true)
            {
                try
                {
                    await CreateRPCClient().GetBlockHashAsync(0);

                    this.state = CoreNodeState.Running;
                    break;
                }
                catch
                {
                }
                if (this.runner.HasExited)
                {
                    break;
                }
            }
        }
        public void CanOverrideAllPorts()
        {
            var extraParams = new NodeConfigParameters
            {
                { "port", "123" },
                { "rpcport", "456" },
                { "apiport", "567" }
            };

            using (var nodeBuilder = NodeBuilder.Create(this))
            {
                var buildAction = new Action <IFullNodeBuilder>(builder =>
                                                                builder.UseBlockStore()
                                                                .UsePowConsensus()
                                                                .UseMempool()
                                                                .AddMining()
                                                                .UseWallet()
                                                                .AddRPC()
                                                                .UseApi()
                                                                .MockIBD());

                var coreNode = nodeBuilder.CreateCustomNode(buildAction, KnownNetworks.StratisRegTest,
                                                            ProtocolVersion.ALT_PROTOCOL_VERSION, configParameters: extraParams);

                coreNode.Start();

                coreNode.ApiPort.Should().Be(567);
                coreNode.FullNode.NodeService <ApiSettings>().ApiPort.Should().Be(567);

                coreNode.RpcPort.Should().Be(456);
                coreNode.FullNode.NodeService <RpcSettings>().RPCPort.Should().Be(456);

                coreNode.ProtocolPort.Should().Be(123);
                coreNode.FullNode.ConnectionManager.ConnectionSettings.ExternalEndpoint.Port.Should().Be(123);
            }
        }
        public CoreNode CreateNode(NodeBuilder nodeBuilder, string agent, ProtocolVersion version = ProtocolVersion.ALT_PROTOCOL_VERSION, NodeConfigParameters configParameters = null)
        {
            var callback = new Action <IFullNodeBuilder>(builder => builder
                                                         .UseBlockStore()
                                                         .UsePosConsensus()
                                                         .UseMempool()
                                                         .AddRPC()
                                                         .UseApi()
                                                         .UseTestChainedHeaderTree()
                                                         .MockIBD()
                                                         );

            return(nodeBuilder.CreateCustomNode(callback, new StratisOverrideRegTest(), ProtocolVersion.PROVEN_HEADER_VERSION, agent: agent, configParameters: configParameters));
        }