public NetworkPeerServerTests(ITestOutputHelper output)
{
this.testOutput = output;
this.extendedLoggerFactory = ExtendedLoggerFactory.Create();
}
public ConsensusManagerBehaviorTestsHelper()
{
this.loggerFactory = ExtendedLoggerFactory.Create();
}
public async Task InitializeAsync()
{
this.blockinfo = new List <Blockinfo>();
List <long> lst = blockinfoarr.Cast <long>().ToList();
for (int i = 0; i < lst.Count; i += 2)
{
this.blockinfo.Add(new Blockinfo {
extranonce = (int)lst[i], nonce = (uint)lst[i + 1]
});
}
// Note that by default, these tests run with size accounting enabled.
this.network = KnownNetworks.RegTest;
byte[] hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG });
this.entry = new TestMemPoolEntryHelper();
this.ChainIndexer = new ChainIndexer(this.network);
this.network.Consensus.Options = new ConsensusOptions();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
var loggerFactory = ExtendedLoggerFactory.Create();
var nodeSettings = new NodeSettings(this.network, args: new string[] { "-checkpoints" });
var consensusSettings = new ConsensusSettings(nodeSettings);
var inMemoryCoinView = new InMemoryCoinView(new HashHeightPair(this.ChainIndexer.Tip));
var nodeStats = new NodeStats(dateTimeProvider, loggerFactory);
this.cachedCoinView = new CachedCoinView(this.network, new Checkpoints(), inMemoryCoinView, dateTimeProvider, new LoggerFactory(), nodeStats, consensusSettings);
var signals = new Signals.Signals(loggerFactory, null);
var asyncProvider = new AsyncProvider(loggerFactory, signals, new NodeLifetime());
var deployments = new NodeDeployments(this.network, this.ChainIndexer);
var genesis = this.network.GetGenesis();
var chainState = new ChainState()
{
BlockStoreTip = new ChainedHeader(genesis.Header, genesis.GetHash(), 0)
};
var consensusRulesContainer = new ConsensusRulesContainer();
foreach (var ruleType in this.network.Consensus.ConsensusRules.HeaderValidationRules)
{
consensusRulesContainer.HeaderValidationRules.Add(Activator.CreateInstance(ruleType) as HeaderValidationConsensusRule);
}
foreach (var ruleType in this.network.Consensus.ConsensusRules.FullValidationRules)
{
FullValidationConsensusRule rule = null;
if (ruleType == typeof(FlushUtxosetRule))
{
rule = new FlushUtxosetRule(new Mock <IInitialBlockDownloadState>().Object);
}
else
{
rule = Activator.CreateInstance(ruleType) as FullValidationConsensusRule;
}
consensusRulesContainer.FullValidationRules.Add(rule);
}
this.ConsensusRules = new PowConsensusRuleEngine(this.network, loggerFactory, dateTimeProvider, this.ChainIndexer, deployments, consensusSettings,
new Checkpoints(), this.cachedCoinView, chainState, new InvalidBlockHashStore(dateTimeProvider), nodeStats, asyncProvider, consensusRulesContainer).SetupRulesEngineParent();
this.consensus = ConsensusManagerHelper.CreateConsensusManager(this.network, chainState: chainState, inMemoryCoinView: inMemoryCoinView, chainIndexer: this.ChainIndexer, consensusRules: this.ConsensusRules);
await this.consensus.InitializeAsync(chainState.BlockStoreTip);
this.entry.Fee(11);
this.entry.Height(11);
var dateTimeProviderSet = new DateTimeProviderSet
{
time = dateTimeProvider.GetTime(),
timeutc = dateTimeProvider.GetUtcNow()
};
this.DateTimeProvider = dateTimeProviderSet;
this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings), loggerFactory, nodeSettings);
this.mempoolLock = new MempoolSchedulerLock();
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
this.baseheight = 0;
var blocks = new List <Block>();
this.txFirst = new List <Transaction>();
this.nonce = 0;
for (int i = 0; i < this.blockinfo.Count; ++i)
{
Block block = this.network.CreateBlock();
block.Header.HashPrevBlock = this.consensus.Tip.HashBlock;
block.Header.Version = 1;
block.Header.Time = Utils.DateTimeToUnixTime(this.ChainIndexer.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = this.network.CreateTransaction();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.ChainIndexer.Height) })));
// Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.AddOutput(new TxOut(Money.Zero, new Script()));
block.AddTransaction(txCoinbase);
if (this.txFirst.Count == 0)
{
this.baseheight = this.ChainIndexer.Height;
}
if (this.txFirst.Count < 4)
{
this.txFirst.Add(block.Transactions[0]);
}
block.Header.Bits = block.Header.GetWorkRequired(this.network, this.ChainIndexer.Tip);
block.UpdateMerkleRoot();
while (!block.CheckProofOfWork())
{
block.Header.Nonce = ++this.nonce;
}
// Serialization sets the BlockSize property.
block = Block.Load(block.ToBytes(), this.network.Consensus.ConsensusFactory);
var res = await this.consensus.BlockMinedAsync(block);
if (res == null)
{
throw new InvalidOperationException();
}
blocks.Add(block);
}
// Just to make sure we can still make simple blocks
this.newBlock = AssemblerForTest(this).Build(this.ChainIndexer.Tip, this.scriptPubKey);
Assert.NotNull(this.newBlock);
}
public PeerSelectorTests()
{
this.extendedLoggerFactory = ExtendedLoggerFactory.Create();
this.connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(new StratisRegTest()));
}
/// <summary>
/// Initializes a new instance of the object.
/// </summary>
/// <param name="network">The network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="protocolVersion">Supported protocol version for which to create the configuration.</param>
/// <param name="agent">The nodes user agent that will be shared with peers.</param>
/// <param name="args">The command-line arguments.</param>
/// <param name="networksSelector">A selector class that delayed load a network for either - regtest/testnet/mainnet.</param>
/// <exception cref="ConfigurationException">Thrown in case of any problems with the configuration file or command line arguments.</exception>
/// <remarks>
/// Processing depends on whether a configuration file is passed via the command line.
/// There are two main scenarios here:
/// - The configuration file is passed via the command line. In this case we need
/// to read it earlier so that it can provide defaults for "testnet" and "regtest".
/// - Alternatively, if the file name is not supplied then a network-specific file
/// name would be determined. In this case we first need to determine the network.
/// </remarks>
public NodeSettings(Network network = null, ProtocolVersion protocolVersion = SupportedProtocolVersion,
string agent = "Blockcore", string[] args = null, NetworksSelector networksSelector = null)
{
// Create the default logger factory and logger.
var loggerFactory = ExtendedLoggerFactory.Create();
this.Logger = loggerFactory.CreateLogger(typeof(NodeSettings).FullName);
// Record arguments.
this.Network = network;
this.ProtocolVersion = protocolVersion;
this.Agent = agent;
this.ConfigReader = new TextFileConfiguration(args ?? new string[] { });
// Log arguments.
this.Logger.LogDebug("Arguments: network='{0}', protocolVersion='{1}', agent='{2}', args='{3}'.",
this.Network == null ? "(None)" : this.Network.Name,
this.ProtocolVersion,
this.Agent,
args == null ? "(None)" : string.Join(" ", args));
// By default, we look for a file named '<network>.conf' in the network's data directory,
// but both the data directory and the configuration file path may be changed using the -datadir and -conf command-line arguments.
this.ConfigurationFile = this.ConfigReader.GetOrDefault <string>("conf", null, this.Logger)?.NormalizeDirectorySeparator();
this.DataDir = this.ConfigReader.GetOrDefault <string>("datadir", null, this.Logger)?.NormalizeDirectorySeparator();
this.DataDirRoot = this.ConfigReader.GetOrDefault <string>("datadirroot", "Blockcore", this.Logger);
// If the configuration file is relative then assume it is relative to the data folder and combine the paths.
if (this.DataDir != null && this.ConfigurationFile != null)
{
bool isRelativePath = Path.GetFullPath(this.ConfigurationFile).Length > this.ConfigurationFile.Length;
if (isRelativePath)
{
this.ConfigurationFile = Path.Combine(this.DataDir, this.ConfigurationFile);
}
}
// If the configuration file has been specified on the command line then read it now
// so that it can provide the defaults for testnet and regtest.
if (this.ConfigurationFile != null)
{
// If the configuration file was specified on the command line then it must exist.
if (!File.Exists(this.ConfigurationFile))
{
throw new ConfigurationException($"Configuration file does not exist at {this.ConfigurationFile}.");
}
// Sets the ConfigReader based on the arguments and the configuration file if it exists.
this.ReadConfigurationFile();
}
// If the network is not known then derive it from the command line arguments.
if (this.Network == null)
{
if (networksSelector == null)
{
throw new ConfigurationException("Network or NetworkSelector not provided.");
}
// Find out if we need to run on testnet or regtest from the config file.
bool testNet = this.ConfigReader.GetOrDefault <bool>("testnet", false, this.Logger);
bool regTest = this.ConfigReader.GetOrDefault <bool>("regtest", false, this.Logger);
if (testNet && regTest)
{
throw new ConfigurationException("Invalid combination of regtest and testnet.");
}
this.Network = testNet ? networksSelector.Testnet() : regTest?networksSelector.Regtest() : networksSelector.Mainnet();
this.Logger.LogDebug("Network set to '{0}'.", this.Network.Name);
}
// Ensure the network being used is registered and we have the correct Network object reference.
this.Network = NetworkRegistration.Register(this.Network);
// Set the full data directory path.
if (this.DataDir == null)
{
// Create the data directories if they don't exist.
this.DataDir = this.CreateDefaultDataDirectories(Path.Combine(this.DataDirRoot, this.Network.RootFolderName), this.Network);
}
else
{
// Combine the data directory with the network's root folder and name.
string directoryPath = Path.Combine(this.DataDir, this.Network.RootFolderName, this.Network.Name);
this.DataDir = Directory.CreateDirectory(directoryPath).FullName;
this.Logger.LogDebug("Data directory initialized with path {0}.", this.DataDir);
}
// Set the data folder.
this.DataFolder = new DataFolder(this.DataDir);
// Attempt to load NLog configuration from the DataFolder.
this.Log = new LogSettings();
this.Log.Load(this.ConfigReader);
this.LoggerFactory = ExtendedLoggerFactory.Create(this.Log);
this.LoggerFactory.AddNLog();
this.LoggerFactory.LoadNLogConfiguration(this.DataFolder);
this.Logger = this.LoggerFactory.CreateLogger(typeof(NodeSettings).FullName);
// Get the configuration file name for the network if it was not specified on the command line.
if (this.ConfigurationFile == null)
{
this.ConfigurationFile = Path.Combine(this.DataDir, this.Network.DefaultConfigFilename);
this.Logger.LogDebug("Configuration file set to '{0}'.", this.ConfigurationFile);
if (File.Exists(this.ConfigurationFile))
{
this.ReadConfigurationFile();
}
}
this.EnableSignalR = this.ConfigReader.GetOrDefault <bool>("enableSignalR", false, this.Logger);
// Create the custom logger factory.
this.LoggerFactory.AddFilters(this.Log, this.DataFolder);
// Load the configuration.
this.LoadConfiguration();
}
public ContractTransferProcessorTests()
{
this.loggerFactory = ExtendedLoggerFactory.Create();
this.network = new SmartContractsRegTest();
this.transferProcessor = new ContractTransferProcessor(this.loggerFactory, this.network);
}