public void CanCheckBlockWithWitness()
{
var block = new Block(Encoders.Hex.DecodeData("000000202f6f6a130549473222411b5c6f54150d63b32aadf10e57f7d563cfc7010000001e28204471ef9ef11acd73543894a96a3044932b85e99889e731322a8ec28a9f9ae9fc56ffff011d0011b40202010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff2c028027266a24aa21a9ed09154465f26a2a4144739eba3e83b3e9ae6a1f69566eae7dc3747d48f1183779010effffffff0250b5062a0100000023210263ed47e995cbbf1bc560101e3b76c6bdb1b094a185450cea533781ce598ff2b6ac0000000000000000266a24aa21a9ed09154465f26a2a4144739eba3e83b3e9ae6a1f69566eae7dc3747d48f1183779012000000000000000000000000000000000000000000000000000000000000000000000000001000000000101cecd90cd38ac6858c47f2fe9f28145d6e18f9c5abc7ef1a41e2f19e6fe0362580100000000ffffffff0130b48d06000000001976a91405481b7f1d90c5a167a15b00e8af76eb6984ea5988ac0247304402206104c335e4adbb920184957f9f710b09de17d015329fde6807b9d321fd2142db02200b24ad996b4aa4ff103000348b5ad690abfd9fddae546af9e568394ed4a83113012103a65786c1a48d4167aca08cf6eb8eed081e13f45c02dc6000fd8f3bb16242579a00000000"));
var consensusFlags = new ConsensusFlags()
{
ScriptFlags = ScriptVerify.Witness | ScriptVerify.P2SH | ScriptVerify.Standard,
LockTimeFlags = LockTimeFlags.MedianTimePast,
EnforceBIP34 = true
};
var context = new ContextInformation()
{
BestBlock = new ContextBlockInformation()
{
MedianTimePast = DateTimeOffset.Parse("2016-03-31T09:02:19+00:00", CultureInfo.InvariantCulture),
Height = 10111
},
NextWorkRequired = block.Header.Bits,
Time = DateTimeOffset.UtcNow,
BlockResult = new BlockResult {
Block = block
},
Flags = consensusFlags,
};
Network.Main.Consensus.Options = new PowConsensusOptions();
var validator = new PowConsensusValidator(Network.Main);
//validator.CheckBlockHeader(context);
validator.ContextualCheckBlock(context);
validator.CheckBlock(context);
}
/// <summary>
/// Constructs a memory pool orphan manager object.
/// </summary>
/// <param name="mempoolLock">A lock for managing asynchronous access to memory pool.</param>
/// <param name="memPool">Transaction memory pool for managing transactions in the memory pool.</param>
/// <param name="chain">Chain of block headers.</param>
/// <param name="signals">Node notifications available to subscribe to.</param>
/// <param name="validator">Memory pool validator for validating transactions.</param>
/// <param name="consensusValidator">Proof of work consensus validator used for validating orphan transactions.</param>
/// <param name="coinView">Coin view of the memory pool.</param>
/// <param name="dateTimeProvider">Date and time information provider.</param>
/// <param name="mempoolSettings">Settings from the memory pool.</param>
/// <param name="loggerFactory">Factory for creating instance logger for this object.</param>
public MempoolOrphans(
MempoolAsyncLock mempoolLock,
TxMempool memPool,
ConcurrentChain chain,
Signals.Signals signals,
IMempoolValidator validator,
PowConsensusValidator consensusValidator,
CoinView coinView,
IDateTimeProvider dateTimeProvider,
MempoolSettings mempoolSettings,
ILoggerFactory loggerFactory)
{
this.MempoolLock = mempoolLock;
this.memPool = memPool;
this.chain = chain;
this.signals = signals;
this.consensusValidator = consensusValidator;
this.coinView = coinView;
this.dateTimeProvider = dateTimeProvider;
this.mempoolSettings = mempoolSettings;
this.Validator = validator;
this.mapOrphanTransactions = new Dictionary <uint256, OrphanTx>();
this.mapOrphanTransactionsByPrev = new Dictionary <OutPoint, List <OrphanTx> >(); // OutPoint already correctly implements equality compare
this.recentRejects = new Dictionary <uint256, uint256>();
this.hashRecentRejectsChainTip = uint256.Zero;
this.mempoolLogger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public FullNodeController(
ILoggerFactory loggerFactory,
IFullNode fullNode = null,
NodeSettings nodeSettings = null,
Network network = null,
PowConsensusValidator consensusValidator = null,
ConcurrentChain chain = null,
ChainState chainState = null,
IndexStoreManager indexManager = null,
BlockStoreManager blockManager = null,
MempoolManager mempoolManager = null,
Connection.IConnectionManager connectionManager = null)
: base(
fullNode: fullNode,
nodeSettings: nodeSettings,
network: network,
consensusValidator: consensusValidator,
chain: chain,
chainState: chainState,
indexManager: indexManager,
blockManager: blockManager,
mempoolManager: mempoolManager,
connectionManager: connectionManager)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public ConsensusManager(ConsensusLoop consensusLoop = null, IDateTimeProvider dateTimeProvider = null, NodeSettings nodeSettings = null, Network network = null,
PowConsensusValidator consensusValidator = null)
{
this.ConsensusLoop = consensusLoop;
this.DateTimeProvider = dateTimeProvider;
this.NodeSettings = nodeSettings;
this.Network = network;
this.ConsensusValidator = consensusValidator;
}
/// <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="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,
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.dateTimeProvider = dateTimeProvider;
this.nodeSettings = nodeSettings;
this.peerBanning = peerBanning;
this.consensusRules = consensusRules;
// chain of stake info can be null if POS is not enabled
this.StakeChain = stakeChain;
}
private uint256 ComputeMerkleRoot(List <uint256> leaves, out bool mutated)
{
LoggerFactory loggerFactory = new LoggerFactory();
ConsensusSettings consensusSettings = new ConsensusSettings(NodeSettings.Default(), loggerFactory);
Network.PurpleMain.Consensus.Options = new PosConsensusOptions();
var consensusValidator = new PowConsensusValidator(Network.PurpleMain, new Checkpoints(Network.PurpleMain, consensusSettings), DateTimeProvider.Default, loggerFactory);
return(consensusValidator.ComputeMerkleRoot(leaves, out mutated));
}
/// <summary>
/// Creates test chain with a consensus loop.
/// </summary>
public static async Task <TestChainContext> CreateAsync(Network network, string dataDir)
{
var testChainContext = new TestChainContext()
{
Network = network
};
testChainContext.NodeSettings = new NodeSettings(network, args: new string[] { $"-datadir={dataDir}" });
if (dataDir != null)
{
testChainContext.NodeSettings.DataDir = dataDir;
}
testChainContext.ConnectionSettings = new ConnectionManagerSettings();
testChainContext.ConnectionSettings.Load(testChainContext.NodeSettings);
testChainContext.LoggerFactory = testChainContext.NodeSettings.LoggerFactory;
testChainContext.DateTimeProvider = DateTimeProvider.Default;
network.Consensus.Options = new PowConsensusOptions();
ConsensusSettings consensusSettings = new ConsensusSettings().Load(testChainContext.NodeSettings);
testChainContext.Checkpoints = new Checkpoints();
PowConsensusValidator consensusValidator = new PowConsensusValidator(network, testChainContext.Checkpoints, testChainContext.DateTimeProvider, testChainContext.LoggerFactory);
testChainContext.Chain = new ConcurrentChain(network);
CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(testChainContext.Chain.Tip.HashBlock), DateTimeProvider.Default, testChainContext.LoggerFactory);
DataFolder dataFolder = new DataFolder(TestBase.AssureEmptyDir(dataDir));
testChainContext.PeerAddressManager = new PeerAddressManager(DateTimeProvider.Default, dataFolder, testChainContext.LoggerFactory, new SelfEndpointTracker());
testChainContext.MockConnectionManager = new Moq.Mock <IConnectionManager>();
testChainContext.MockReadOnlyNodesCollection = new Moq.Mock <IReadOnlyNetworkPeerCollection>();
testChainContext.MockConnectionManager.Setup(s => s.ConnectedPeers).Returns(testChainContext.MockReadOnlyNodesCollection.Object);
testChainContext.MockConnectionManager.Setup(s => s.NodeSettings).Returns(testChainContext.NodeSettings);
testChainContext.MockConnectionManager.Setup(s => s.ConnectionSettings).Returns(testChainContext.ConnectionSettings);
testChainContext.ConnectionManager = testChainContext.MockConnectionManager.Object;
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(testChainContext.Chain, testChainContext.ConnectionManager, testChainContext.LoggerFactory);
testChainContext.PeerBanning = new PeerBanning(testChainContext.ConnectionManager, testChainContext.LoggerFactory, testChainContext.DateTimeProvider, testChainContext.PeerAddressManager);
NodeDeployments deployments = new NodeDeployments(testChainContext.Network, testChainContext.Chain);
ConsensusRules consensusRules = new PowConsensusRules(testChainContext.Network, testChainContext.LoggerFactory, testChainContext.DateTimeProvider, testChainContext.Chain, deployments, consensusSettings, testChainContext.Checkpoints).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration());
testChainContext.Consensus = new ConsensusLoop(new AsyncLoopFactory(testChainContext.LoggerFactory), consensusValidator, new NodeLifetime(), testChainContext.Chain, cachedCoinView, blockPuller, new NodeDeployments(network, testChainContext.Chain), testChainContext.LoggerFactory, new ChainState(new InvalidBlockHashStore(testChainContext.DateTimeProvider)), testChainContext.ConnectionManager, testChainContext.DateTimeProvider, new Signals.Signals(), consensusSettings, testChainContext.NodeSettings, testChainContext.PeerBanning, consensusRules);
await testChainContext.Consensus.StartAsync();
return(testChainContext);
}
public MempoolValidator(TxMempool memPool, MempoolScheduler mempoolScheduler,
PowConsensusValidator consensusValidator, IDateTimeProvider dateTimeProvider, NodeSettings nodeArgs,
ConcurrentChain chain, CoinView coinView)
{
this.memPool = memPool;
this.mempoolScheduler = mempoolScheduler;
this.consensusValidator = consensusValidator;
this.dateTimeProvider = dateTimeProvider;
this.nodeArgs = nodeArgs;
this.chain = chain;
this.coinView = coinView;
freeLimiter = new FreeLimiterSection();
this.PerformanceCounter = new MempoolPerformanceCounter();
}
public MempoolOrphans(MempoolScheduler mempoolScheduler, TxMempool memPool, ConcurrentChain chain,
MempoolValidator validator, PowConsensusValidator consensusValidator, CoinView coinView, IDateTimeProvider dateTimeProvider, NodeSettings nodeArgs)
{
this.MempoolScheduler = mempoolScheduler;
this.memPool = memPool;
this.chain = chain;
this.consensusValidator = consensusValidator;
this.coinView = coinView;
this.dateTimeProvider = dateTimeProvider;
this.nodeArgs = nodeArgs;
this.Validator = validator;
this.mapOrphanTransactions = new Dictionary <uint256, OrphanTx>();
this.mapOrphanTransactionsByPrev = new Dictionary <OutPoint, List <OrphanTx> >(); // OutPoint already correctly implements equality compare
this.recentRejects = new Dictionary <uint256, uint256>();
this.hashRecentRejectsChainTip = uint256.Zero;
}
private static MempoolManager CreateTestMempool(NodeSettings settings, out TxMempool txMemPool)
{
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
txMemPool = new TxMempool(new FeeRate(1000), settings);
var mempoolScheduler = new MempoolScheduler();
var coins = new InMemoryCoinView(settings.Network.GenesisHash);
var chain = new ConcurrentChain(Network.Main.GetGenesis().Header);
var mempoolPersistence = new MempoolPersistence(settings);
NBitcoin.Network.Main.Consensus.Options = new PosConsensusOptions();
var consensusValidator = new PowConsensusValidator(NBitcoin.Network.Main);
var mempoolValidator = new MempoolValidator(txMemPool, mempoolScheduler, consensusValidator, dateTimeProvider, settings, chain, coins);
var mempoolOrphans = new MempoolOrphans(mempoolScheduler, txMemPool, chain, mempoolValidator, consensusValidator, coins, dateTimeProvider, settings);
return(new MempoolManager(mempoolScheduler, txMemPool, mempoolValidator, mempoolOrphans, dateTimeProvider, settings, mempoolPersistence));
}
private static MempoolManager CreateTestMempool(NodeSettings settings, out TxMempool txMemPool)
{
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
txMemPool = new TxMempool(new FeeRate(1000), dateTimeProvider, new BlockPolicyEstimator(new FeeRate(1000), NodeSettings.Default(), new LoggerFactory()), new LoggerFactory());
var mempoolLock = new MempoolAsyncLock();
var coins = new InMemoryCoinView(settings.Network.GenesisHash);
var chain = new ConcurrentChain(Network.Main.GetGenesis().Header);
var mempoolPersistence = new MempoolPersistence(settings, new LoggerFactory());
NBitcoin.Network.Main.Consensus.Options = new PosConsensusOptions();
var consensusValidator = new PowConsensusValidator(NBitcoin.Network.Main);
var mempoolValidator = new MempoolValidator(txMemPool, mempoolLock, consensusValidator, dateTimeProvider, settings, chain, coins, new LoggerFactory());
var mempoolOrphans = new MempoolOrphans(mempoolLock, txMemPool, chain, new Bitcoin.Signals.Signals(), mempoolValidator, consensusValidator, coins, dateTimeProvider, settings, new LoggerFactory());
return(new MempoolManager(mempoolLock, txMemPool, mempoolValidator, mempoolOrphans, dateTimeProvider, settings, mempoolPersistence, coins, new LoggerFactory()));
}
/// <summary>
/// Creates test chain with a consensus loop.
/// </summary>
public static async Task <TestChainContext> CreateAsync(Network network, string dataDir)
{
var testChainContext = new TestChainContext()
{
Network = network
};
testChainContext.NodeSettings = new NodeSettings(network.Name, network).LoadArguments(new string[] { $"-datadir={dataDir}" });
if (dataDir != null)
{
testChainContext.NodeSettings.DataDir = dataDir;
}
testChainContext.LoggerFactory = new ExtendedLoggerFactory();
testChainContext.LoggerFactory.AddConsoleWithFilters();
testChainContext.DateTimeProvider = DateTimeProvider.Default;
network.Consensus.Options = new PowConsensusOptions();
ConsensusSettings consensusSettings = new ConsensusSettings(testChainContext.NodeSettings, testChainContext.LoggerFactory);
PowConsensusValidator consensusValidator = new PowConsensusValidator(network, new Checkpoints(network, consensusSettings), testChainContext.DateTimeProvider, testChainContext.LoggerFactory);
testChainContext.Chain = new ConcurrentChain(network);
CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(testChainContext.Chain.Tip.HashBlock), DateTimeProvider.Default, testChainContext.LoggerFactory);
testChainContext.MockConnectionManager = new Moq.Mock <IConnectionManager>();
testChainContext.MockReadOnlyNodesCollection = new Moq.Mock <IReadOnlyNetworkPeerCollection>();
testChainContext.MockConnectionManager.Setup(s => s.ConnectedNodes).Returns(testChainContext.MockReadOnlyNodesCollection.Object);
testChainContext.MockConnectionManager.Setup(s => s.NodeSettings).Returns(testChainContext.NodeSettings);
testChainContext.ConnectionManager = testChainContext.MockConnectionManager.Object;
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(testChainContext.Chain, testChainContext.ConnectionManager, new LoggerFactory());
testChainContext.PeerBanning = new PeerBanning(testChainContext.ConnectionManager, testChainContext.LoggerFactory, testChainContext.DateTimeProvider, testChainContext.NodeSettings);
testChainContext.Consensus = new ConsensusLoop(new AsyncLoopFactory(testChainContext.LoggerFactory), consensusValidator, new NodeLifetime(), testChainContext.Chain, cachedCoinView, blockPuller, new NodeDeployments(network, testChainContext.Chain), testChainContext.LoggerFactory, new ChainState(new FullNode(), new InvalidBlockHashStore(testChainContext.DateTimeProvider)), testChainContext.ConnectionManager, testChainContext.DateTimeProvider, new Signals.Signals(), new Checkpoints(network, consensusSettings), consensusSettings, testChainContext.NodeSettings, testChainContext.PeerBanning);
await testChainContext.Consensus.StartAsync();
return(testChainContext);
}
public MempoolValidator(
TxMempool memPool,
MempoolScheduler mempoolScheduler,
PowConsensusValidator consensusValidator,
IDateTimeProvider dateTimeProvider,
NodeSettings nodeArgs,
ConcurrentChain chain,
CoinView coinView,
ILoggerFactory loggerFactory)
{
this.memPool = memPool;
this.mempoolScheduler = mempoolScheduler;
this.consensusValidator = consensusValidator;
this.dateTimeProvider = dateTimeProvider;
this.nodeArgs = nodeArgs;
this.chain = chain;
this.coinView = coinView;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.freeLimiter = new FreeLimiterSection();
this.PerformanceCounter = new MempoolPerformanceCounter();
}
private static MempoolManager CreateTestMempool(NodeSettings settings, out TxMempool txMemPool)
{
var mempoolSettings = new MempoolSettings(settings);
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
NodeSettings nodeSettings = NodeSettings.Default();
var loggerFactory = nodeSettings.LoggerFactory;
ConsensusSettings consensusSettings = new ConsensusSettings().Load(nodeSettings);
txMemPool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings), loggerFactory, nodeSettings);
var mempoolLock = new MempoolSchedulerLock();
var coins = new InMemoryCoinView(settings.Network.GenesisHash);
var chain = new ConcurrentChain(Network.Main.GetGenesis().Header);
var mempoolPersistence = new MempoolPersistence(settings, loggerFactory);
Network.Main.Consensus.Options = new PosConsensusOptions();
var consensusValidator = new PowConsensusValidator(Network.Main, new Checkpoints(Network.Main, consensusSettings), dateTimeProvider, loggerFactory);
var mempoolValidator = new MempoolValidator(txMemPool, mempoolLock, consensusValidator, dateTimeProvider, mempoolSettings, chain, coins, loggerFactory, settings);
var mempoolOrphans = new MempoolOrphans(mempoolLock, txMemPool, chain, new Signals.Signals(), mempoolValidator, consensusValidator, coins, dateTimeProvider, mempoolSettings, loggerFactory);
return(new MempoolManager(mempoolLock, txMemPool, mempoolValidator, mempoolOrphans, dateTimeProvider, mempoolSettings, mempoolPersistence, coins, loggerFactory, settings.Network));
}
public FullNodeController(
IFullNode fullNode = null,
NodeSettings nodeSettings = null,
Network network = null,
PowConsensusValidator consensusValidator = null,
ConcurrentChain chain = null,
ChainBehavior.ChainState chainState = null,
BlockStoreManager blockManager = null,
MempoolManager mempoolManager = null,
Connection.ConnectionManager connectionManager = null)
: base(
fullNode: fullNode,
nodeSettings: nodeSettings,
network: network,
consensusValidator: consensusValidator,
chain: chain,
chainState: chainState,
blockManager: blockManager,
mempoolManager: mempoolManager,
connectionManager: connectionManager)
{
}
public BaseRPCController(
IFullNode fullNode = null,
NodeSettings nodeSettings = null,
Network network = null,
PowConsensusValidator consensusValidator = null,
ConsensusLoop consensusLoop = null,
ConcurrentChain chain = null,
ChainState chainState = null,
BlockStoreManager blockManager = null,
MempoolManager mempoolManager = null,
Connection.IConnectionManager connectionManager = null)
{
this.FullNode = fullNode;
this.Settings = nodeSettings;
this.Network = network;
this.ConsensusValidator = consensusValidator;
this.ConsensusLoop = consensusLoop;
this.Chain = chain;
this.ChainState = chainState;
this.BlockManager = blockManager;
this.MempoolManager = mempoolManager;
this.ConnectionManager = connectionManager;
}
public async Task InitializeAsync()
{
this.blockinfo = new List <Blockinfo>();
var 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 = Network.Main;
var hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG });
this.newBlock = new BlockTemplate(this.network);
this.entry = new TestMemPoolEntryHelper();
this.chain = new ConcurrentChain(this.network);
this.network.Consensus.Options = new PowConsensusOptions();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
this.cachedCoinView = new CachedCoinView(new InMemoryCoinView(this.chain.Tip.HashBlock), dateTimeProvider, new LoggerFactory());
var loggerFactory = new ExtendedLoggerFactory();
loggerFactory.AddConsoleWithFilters();
NodeSettings nodeSettings = new NodeSettings(args: new string[] { "-checkpoints" });
var consensusSettings = new ConsensusSettings().Load(nodeSettings);
PowConsensusValidator consensusValidator = new PowConsensusValidator(this.network, new Checkpoints(), dateTimeProvider, loggerFactory);
NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(this.network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker());
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker());
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings);
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(this.chain, connectionManager, new LoggerFactory());
PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager);
NodeDeployments deployments = new NodeDeployments(this.network, this.chain);
ConsensusRules consensusRules = new PowConsensusRules(this.network, loggerFactory, dateTimeProvider, this.chain, deployments, consensusSettings, new Checkpoints(), this.cachedCoinView, blockPuller).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration());
this.consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), this.chain, this.cachedCoinView, blockPuller, new NodeDeployments(this.network, this.chain), loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules);
await this.consensus.StartAsync();
this.entry.Fee(11);
this.entry.Height(11);
var date1 = new MemoryPoolTests.DateTimeProviderSet();
date1.time = dateTimeProvider.GetTime();
date1.timeutc = dateTimeProvider.GetUtcNow();
this.DateTimeProvider = date1;
this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), new LoggerFactory(), nodeSettings), new LoggerFactory(), nodeSettings);
this.mempoolLock = new MempoolSchedulerLock();
// Simple block creation, nothing special yet:
this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey);
this.chain.SetTip(this.newBlock.Block.Header);
await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = this.newBlock.Block
}, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
this.baseheight = 0;
List <Block> blocks = new List <Block>();
this.txFirst = new List <Transaction>();
for (int i = 0; i < this.blockinfo.Count; ++i)
{
var pblock = this.newBlock.Block.Clone(); // pointer for convenience
pblock.Header.HashPrevBlock = this.chain.Tip.HashBlock;
pblock.Header.Version = 1;
pblock.Header.Time = Utils.DateTimeToUnixTime(this.chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = pblock.Transactions[0].Clone();
txCoinbase.Inputs.Clear();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.chain.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()));
pblock.Transactions[0] = txCoinbase;
if (this.txFirst.Count == 0)
{
this.baseheight = this.chain.Height;
}
if (this.txFirst.Count < 4)
{
this.txFirst.Add(pblock.Transactions[0]);
}
pblock.UpdateMerkleRoot();
pblock.Header.Nonce = this.blockinfo[i].nonce;
this.chain.SetTip(pblock.Header);
await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = pblock
}, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
blocks.Add(pblock);
}
// Just to make sure we can still make simple blocks
this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey);
Assert.NotNull(this.newBlock);
}
/// <summary>
/// Creates the test chain with some default blocks and txs.
/// </summary>
/// <param name="network">Network to create the chain on.</param>
/// <param name="scriptPubKey">Public key to create blocks/txs with.</param>
/// <returns>Context object representing the test chain.</returns>
public static async Task <ITestChainContext> CreateAsync(Network network, Script scriptPubKey, string dataDir)
{
NodeSettings nodeSettings = new NodeSettings(network, args: new string[] { $"-datadir={dataDir}" });
var loggerFactory = nodeSettings.LoggerFactory;
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
network.Consensus.Options = new PowConsensusOptions();
ConsensusSettings consensusSettings = new ConsensusSettings().Load(nodeSettings);
PowConsensusValidator consensusValidator = new PowConsensusValidator(network, new Checkpoints(), dateTimeProvider, loggerFactory);
ConcurrentChain chain = new ConcurrentChain(network);
CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(chain.Tip.HashBlock), DateTimeProvider.Default, loggerFactory);
NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads());
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory);
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings);
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(chain, connectionManager, new LoggerFactory());
PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, nodeSettings);
NodeDeployments deployments = new NodeDeployments(network, chain);
ConsensusRules consensusRules = new PowConsensusRules(network, loggerFactory, dateTimeProvider, chain, deployments, consensusSettings, new Checkpoints()).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration());
ConsensusLoop consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), chain, cachedCoinView, blockPuller, deployments, loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules);
await consensus.StartAsync();
BlockPolicyEstimator blockPolicyEstimator = new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings);
TxMempool mempool = new TxMempool(dateTimeProvider, blockPolicyEstimator, loggerFactory, nodeSettings);
MempoolSchedulerLock mempoolLock = new MempoolSchedulerLock();
// Simple block creation, nothing special yet:
PowBlockAssembler blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory as LoggerFactory);
BlockTemplate newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
chain.SetTip(newBlock.Block.Header);
await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = newBlock.Block
}, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
List <BlockInfo> blockinfo = CreateBlockInfoList();
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
int baseheight = 0;
List <Block> blocks = new List <Block>();
List <Transaction> srcTxs = new List <Transaction>();
for (int i = 0; i < blockinfo.Count; ++i)
{
Block currentBlock = newBlock.Block.Clone(); // pointer for convenience
currentBlock.Header.HashPrevBlock = chain.Tip.HashBlock;
currentBlock.Header.Version = 1;
currentBlock.Header.Time = Utils.DateTimeToUnixTime(chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = currentBlock.Transactions[0].Clone();
txCoinbase.Inputs.Clear();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(blockinfo[i].extraNonce), Op.GetPushOp(chain.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()));
currentBlock.Transactions[0] = txCoinbase;
if (srcTxs.Count == 0)
{
baseheight = chain.Height;
}
if (srcTxs.Count < 4)
{
srcTxs.Add(currentBlock.Transactions[0]);
}
currentBlock.UpdateMerkleRoot();
currentBlock.Header.Nonce = blockinfo[i].nonce;
chain.SetTip(currentBlock.Header);
await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = currentBlock
}, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
blocks.Add(currentBlock);
}
// Just to make sure we can still make simple blocks
blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory as LoggerFactory);
newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
MempoolValidator mempoolValidator = new MempoolValidator(mempool, mempoolLock, consensusValidator, dateTimeProvider, new MempoolSettings(nodeSettings), chain, cachedCoinView, loggerFactory, nodeSettings);
return(new TestChainContext {
MempoolValidator = mempoolValidator, SrcTxs = srcTxs
});
}
/// <summary>
/// Creates the test chain with some default blocks and txs.
/// </summary>
/// <param name="network">Network to create the chain on.</param>
/// <param name="scriptPubKey">Public key to create blocks/txs with.</param>
/// <returns>Context object representing the test chain.</returns>
public static ITestChainContext Create(Network network, Script scriptPubKey)
{
NodeSettings nodeSettings = NodeSettings.Default();
LoggerFactory loggerFactory = new LoggerFactory();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
network.Consensus.Options = new PowConsensusOptions();
PowConsensusValidator consensusValidator = new PowConsensusValidator(network);
ConcurrentChain chain = new ConcurrentChain(network);
CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(chain.Tip.HashBlock), loggerFactory);
ConnectionManager connectionManager = new ConnectionManager(network, new NodeConnectionParameters(), nodeSettings, loggerFactory, new NodeLifetime());
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(chain, connectionManager, new LoggerFactory());
ConsensusLoop consensus = new ConsensusLoop(consensusValidator, chain, cachedCoinView, blockPuller, new NodeDeployments(network));
consensus.Initialize();
BlockPolicyEstimator blockPolicyEstimator = new BlockPolicyEstimator(new FeeRate(1000), nodeSettings, loggerFactory);
TxMempool mempool = new TxMempool(new FeeRate(1000), dateTimeProvider, blockPolicyEstimator, loggerFactory);
MempoolAsyncLock mempoolLock = new MempoolAsyncLock();
// Simple block creation, nothing special yet:
PowBlockAssembler blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider);
BlockTemplate newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
chain.SetTip(newBlock.Block.Header);
consensus.AcceptBlock(new ContextInformation(new BlockResult {
Block = newBlock.Block
}, network.Consensus)
{
CheckPow = false, CheckMerkleRoot = false
});
List <BlockInfo> blockinfo = CreateBlockInfoList();
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
int baseheight = 0;
List <Block> blocks = new List <Block>();
List <Transaction> srcTxs = new List <Transaction>();
for (int i = 0; i < blockinfo.Count; ++i)
{
Block currentBlock = newBlock.Block.Clone(); // pointer for convenience
currentBlock.Header.HashPrevBlock = chain.Tip.HashBlock;
currentBlock.Header.Version = 1;
currentBlock.Header.Time = Utils.DateTimeToUnixTime(chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = currentBlock.Transactions[0].Clone();
txCoinbase.Inputs.Clear();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(blockinfo[i].extraNonce), Op.GetPushOp(chain.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()));
currentBlock.Transactions[0] = txCoinbase;
if (srcTxs.Count == 0)
{
baseheight = chain.Height;
}
if (srcTxs.Count < 4)
{
srcTxs.Add(currentBlock.Transactions[0]);
}
currentBlock.UpdateMerkleRoot();
currentBlock.Header.Nonce = blockinfo[i].nonce;
chain.SetTip(currentBlock.Header);
consensus.AcceptBlock(new ContextInformation(new BlockResult {
Block = currentBlock
}, network.Consensus)
{
CheckPow = false, CheckMerkleRoot = false
});
blocks.Add(currentBlock);
}
// Just to make sure we can still make simple blocks
blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider);
newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
MempoolValidator mempoolValidator = new MempoolValidator(mempool, mempoolLock, consensusValidator, dateTimeProvider, nodeSettings, chain, cachedCoinView, loggerFactory);
return(new TestChainContext {
MempoolValidator = mempoolValidator, SrcTxs = srcTxs
});
}
