/// <summary>
/// Initialize a new instance of <see cref="ConsensusLoop"/>.
/// </summary>
/// <param name="asyncLoopFactory">The async loop we need to wait upon before we can shut down this feature.</param>
/// <param name="validator">The validation logic for the consensus rules.</param>
/// <param name="nodeLifetime">Contain information about the life time of the node, its used on startup and shutdown.</param>
/// <param name="chain">A chain of headers all the way to genesis.</param>
/// <param name="utxoSet">The consensus db, containing all unspent UTXO in the chain.</param>
/// <param name="puller">A puller that can pull blocks from peers on demand.</param>
/// <param name="nodeDeployments">Contain information about deployment and activation of features in the chain.</param>
/// <param name="loggerFactory">A factory to provide logger instances.</param>
/// <param name="chainState">Holds state related to the block chain.</param>
/// <param name="connectionManager">Connection manager of all the currently connected peers.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="signals">A signaler that used to signal messages between features.</param>
/// <param name="checkpoints">Provider of block header hash checkpoints.</param>
/// <param name="consensusSettings">Consensus settings for the full node.</param>
/// <param name="nodeSettings">Settings for the full node.</param>
/// <param name="peerBanning">Handles the banning of peers.</param>
/// <param name="consensusRules">The consensus rules to validate.</param>
/// <param name="stakeChain">Information holding POS data chained.</param>
public ConsensusLoop(
IAsyncLoopFactory asyncLoopFactory,
PowConsensusValidator validator,
INodeLifetime nodeLifetime,
ConcurrentChain chain,
CoinView utxoSet,
LookaheadBlockPuller puller,
NodeDeployments nodeDeployments,
ILoggerFactory loggerFactory,
ChainState chainState,
IConnectionManager connectionManager,
IDateTimeProvider dateTimeProvider,
Signals.Signals signals,
ICheckpoints checkpoints,
ConsensusSettings consensusSettings,
NodeSettings nodeSettings,
IPeerBanning peerBanning,
IConsensusRules consensusRules,
StakeChain stakeChain = null)
{
Guard.NotNull(asyncLoopFactory, nameof(asyncLoopFactory));
Guard.NotNull(validator, nameof(validator));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(chain, nameof(chain));
Guard.NotNull(utxoSet, nameof(utxoSet));
Guard.NotNull(puller, nameof(puller));
Guard.NotNull(nodeDeployments, nameof(nodeDeployments));
Guard.NotNull(connectionManager, nameof(connectionManager));
Guard.NotNull(chainState, nameof(chainState));
Guard.NotNull(signals, nameof(signals));
Guard.NotNull(consensusSettings, nameof(consensusSettings));
Guard.NotNull(nodeSettings, nameof(nodeSettings));
Guard.NotNull(peerBanning, nameof(peerBanning));
Guard.NotNull(consensusRules, nameof(consensusRules));
this.consensusLock = new AsyncLock();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.asyncLoopFactory = asyncLoopFactory;
this.Validator = validator;
this.nodeLifetime = nodeLifetime;
this.chainState = chainState;
this.connectionManager = connectionManager;
this.signals = signals;
this.Chain = chain;
this.UTXOSet = utxoSet;
this.Puller = puller;
this.NodeDeployments = nodeDeployments;
this.checkpoints = checkpoints;
this.dateTimeProvider = dateTimeProvider;
this.consensusSettings = consensusSettings;
this.nodeSettings = nodeSettings;
this.peerBanning = peerBanning;
this.consensusRules = consensusRules;
// chain of stake info can be null if POS is not enabled
this.StakeChain = stakeChain;
}
/// <summary>
/// Creates a new instance of the <see cref="InitialBlockDownloadState" /> class.
/// </summary>
/// <param name="chainState">Information about node's chain.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="nodeSettings">User defined node settings.</param>
/// <param name="checkpoints">Provider of block header hash checkpoints.</param>
public InitialBlockDownloadState(IChainState chainState, Network network, ConsensusSettings consensusSettings, ICheckpoints checkpoints)
{
this.network = network;
this.consensusSettings = consensusSettings;
this.chainState = chainState;
this.checkpoints = checkpoints;
this.dateTimeProvider = DateTimeProvider.Default;
}
/// <summary>
/// Initializes a new instance of the object.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet/stratis test/main.</param>
/// <param name="consensusSettings">Consensus settings for node - used to see if checkpoints have been disabled or not.</param>
public Checkpoints(Network network, ConsensusSettings consensusSettings)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(consensusSettings, nameof(consensusSettings));
this.consensusSettings = consensusSettings;
this.network = network;
}
public ConsensusFeature(
IAsyncLoopFactory asyncLoopFactory,
DBreezeCoinView dBreezeCoinView,
Network network,
PowConsensusValidator consensusValidator,
ConcurrentChain chain,
LookaheadBlockPuller blockPuller,
CoinView coinView,
ChainState chainState,
IConnectionManager connectionManager,
INodeLifetime nodeLifetime,
Signals.Signals signals,
ConsensusLoop consensusLoop,
NodeSettings nodeSettings,
NodeDeployments nodeDeployments,
ILoggerFactory loggerFactory,
IDateTimeProvider dateTimeProvider,
ConsensusManager consensusManager,
ConsensusStats consensusStats,
ConsensusSettings consensusSettings,
IRuleRegistration ruleRegistration,
IConsensusRules consensusRules,
StakeChainStore stakeChain = null)
{
this.dBreezeCoinView = dBreezeCoinView;
this.consensusValidator = consensusValidator;
this.chain = chain;
this.blockPuller = blockPuller;
this.coinView = coinView;
this.chainState = chainState;
this.connectionManager = connectionManager;
this.nodeLifetime = nodeLifetime;
this.signals = signals;
this.network = network;
this.consensusLoop = consensusLoop;
this.nodeSettings = nodeSettings;
this.nodeDeployments = nodeDeployments;
this.stakeChain = stakeChain;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.loggerFactory = loggerFactory;
this.dateTimeProvider = dateTimeProvider;
this.consensusManager = consensusManager;
this.consensusStats = consensusStats;
this.consensusSettings = consensusSettings;
this.ruleRegistration = ruleRegistration;
this.consensusRules = consensusRules;
this.chainState.MaxReorgLength = this.network.Consensus.Option <PowConsensusOptions>().MaxReorgLength;
}
/// <summary>
/// Initializes a new instance of the object.
/// </summary>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet/stratis test/main.</param>
/// <param name="settings">Consensus settings for node - used to see if checkpoints have been disabled or not.</param>
public Checkpoints(Network network, ConsensusSettings settings)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(settings, nameof(settings));
if (!settings.UseCheckpoints)
{
this.checkpoints = new Dictionary <int, CheckpointInfo>();
}
else if (network.Equals(Network.Main))
{
this.checkpoints = bitcoinMainnetCheckpoints;
}
else if (network.Equals(Network.TestNet))
{
this.checkpoints = bitcoinTestnetCheckpoints;
}
else if (network.Equals(Network.RegTest))
{
this.checkpoints = new Dictionary <int, CheckpointInfo>();
}
else if (network.Equals(Network.StratisMain))
{
this.checkpoints = stratisMainnetCheckpoints;
}
else if (network.Equals(Network.StratisTest))
{
this.checkpoints = stratisTestnetCheckpoints;
}
else if (network.Equals(Network.ImpleumMain))
{
this.checkpoints = impleumMainnetCheckpoints;
}
else if (network.Equals(Network.ImpleumTest))
{
this.checkpoints = impleumTestnetCheckpoints;
}
else
{
this.checkpoints = new Dictionary <int, CheckpointInfo>();
}
}
public ConsensusFeature(
DBreezeCoinView dBreezeCoinView,
Network network,
LookaheadBlockPuller blockPuller,
CoinView coinView,
IChainState chainState,
IConnectionManager connectionManager,
Signals.Signals signals,
IConsensusLoop consensusLoop,
NodeDeployments nodeDeployments,
ILoggerFactory loggerFactory,
ConsensusStats consensusStats,
IRuleRegistration ruleRegistration,
IConsensusRules consensusRules,
NodeSettings nodeSettings,
ConsensusSettings consensusSettings,
StakeChainStore stakeChain = null)
{
this.dBreezeCoinView = dBreezeCoinView;
this.blockPuller = blockPuller;
this.coinView = coinView;
this.chainState = chainState;
this.connectionManager = connectionManager;
this.signals = signals;
this.consensusLoop = consensusLoop;
this.nodeDeployments = nodeDeployments;
this.stakeChain = stakeChain;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.loggerFactory = loggerFactory;
this.consensusStats = consensusStats;
this.ruleRegistration = ruleRegistration;
this.nodeSettings = nodeSettings;
this.consensusSettings = consensusSettings;
this.consensusRules = consensusRules;
this.chainState.MaxReorgLength = network.Consensus.MaxReorgLength;
}
/// <summary>
/// Get the default configuration.
/// </summary>
/// <param name="builder">The string builder to add the settings to.</param>
/// <param name="network">The network to base the defaults off.</param>
public static void BuildDefaultConfigurationFile(StringBuilder builder, Network network)
{
ConsensusSettings.BuildDefaultConfigurationFile(builder, network);
}
/// <summary>
/// Prints command-line help.
/// </summary>
/// <param name="network">The network to extract values from.</param>
public static void PrintHelp(Network network)
{
ConsensusSettings.PrintHelp(network);
}