/// <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 PosBlockAssembler(
ConsensusLoop consensusLoop,
Network network,
ConcurrentChain chain,
MempoolAsyncLock mempoolLock,
TxMempool mempool,
IDateTimeProvider dateTimeProvider,
StakeChain stakeChain,
ILogger logger,
AssemblerOptions options = null)
: base(consensusLoop, network, chain, mempoolLock, mempool, dateTimeProvider, logger, options)
{
this.stakeChain = stakeChain;
}
public PosBlockAssembler(
ConsensusLoop consensusLoop,
Network network,
MempoolAsyncLock mempoolLock,
TxMempool mempool,
IDateTimeProvider dateTimeProvider,
StakeChain stakeChain,
ChainedBlock chainTip,
ILoggerFactory loggerFactory,
AssemblerOptions options = null)
: base(consensusLoop, network, mempoolLock, mempool, dateTimeProvider, chainTip, loggerFactory, options)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
}
public PowBlockAssembler(
ConsensusLoop consensusLoop,
Network network,
MempoolAsyncLock mempoolLock,
TxMempool mempool,
IDateTimeProvider dateTimeProvider,
ChainedBlock chainTip,
ILoggerFactory loggerFactory,
AssemblerOptions options = null)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
options = options ?? new AssemblerOptions();
this.blockMinFeeRate = options.BlockMinFeeRate;
// Limit weight to between 4K and MAX_BLOCK_WEIGHT-4K for sanity.
this.blockMaxWeight = (uint)Math.Max(4000, Math.Min(PowMining.DefaultBlockMaxWeight - 4000, options.BlockMaxWeight));
// Limit size to between 1K and MAX_BLOCK_SERIALIZED_SIZE-1K for sanity.
this.blockMaxSize = (uint)Math.Max(1000, Math.Min(network.Consensus.Option <PowConsensusOptions>().MaxBlockSerializedSize - 1000, options.BlockMaxSize));
// Whether we need to account for byte usage (in addition to weight usage).
this.needSizeAccounting = (this.blockMaxSize < network.Consensus.Option <PowConsensusOptions>().MaxBlockSerializedSize - 1000);
this.consensusLoop = consensusLoop;
this.mempoolLock = mempoolLock;
this.mempool = mempool;
this.dateTimeProvider = dateTimeProvider;
this.options = options;
this.network = network;
this.inBlock = new TxMempool.SetEntries();
// Reserve space for coinbase tx.
this.blockSize = 1000;
this.blockWeight = 4000;
this.blockSigOpsCost = 400;
this.fIncludeWitness = false;
// These counters do not include coinbase tx.
this.blockTx = 0;
this.fees = 0;
this.ChainTip = chainTip;
this.pblocktemplate = new BlockTemplate {
Block = new Block(), VTxFees = new List <Money>()
};
}
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()));
}
public PosAssemblerFactory(
ConsensusLoop consensusLoop,
Network network,
MempoolAsyncLock mempoolScheduler,
TxMempool mempool,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
StakeChain stakeChain = null)
{
this.consensusLoop = consensusLoop;
this.network = network;
this.mempoolScheduler = mempoolScheduler;
this.mempool = mempool;
this.dateTimeProvider = dateTimeProvider;
this.stakeChain = stakeChain;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
/// <summary>
/// Constructs an instance of a memory pool 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="validator">Memory pool validator for validating transactions.</param>
/// <param name="orphans">Memory pool orphans for managing orphan transactions.</param>
/// <param name="dateTimeProvider">Date and time information provider.</param>
/// <param name="nodeArgs">Settings from the node.</param>
/// <param name="mempoolPersistence">Memory pool persistence methods for loading and saving from storage.</param>
/// <param name="loggerFactory">Logger factory for creating instance logger.</param>
public MempoolManager(
MempoolAsyncLock mempoolLock,
TxMempool memPool,
IMempoolValidator validator,
MempoolOrphans orphans,
IDateTimeProvider dateTimeProvider,
NodeSettings nodeArgs,
IMempoolPersistence mempoolPersistence,
ILoggerFactory loggerFactory)
{
this.MempoolLock = mempoolLock;
this.memPool = memPool;
this.DateTimeProvider = dateTimeProvider;
this.NodeArgs = nodeArgs;
this.Orphans = orphans;
this.Validator = validator;
this.mempoolPersistence = mempoolPersistence;
this.mempoolLogger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public TestContext()
{
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.entry = new TestMemPoolEntryHelper();
this.chain = new ConcurrentChain(this.network);
this.network.Consensus.Options = new PowConsensusOptions();
this.cachedCoinView = new CachedCoinView(new InMemoryCoinView(this.chain.Tip.HashBlock), new LoggerFactory());
this.consensus = new ConsensusLoop(new PowConsensusValidator(this.network), this.chain, this.cachedCoinView, new LookaheadBlockPuller(this.chain, new ConnectionManager(this.network, new NodeConnectionParameters(), new NodeSettings(), new LoggerFactory(), new NodeLifetime()), new LoggerFactory()), new NodeDeployments(this.network));
this.consensus.Initialize();
this.entry.Fee(11);
this.entry.Height(11);
var date1 = new MemoryPoolTests.DateTimeProviderSet();
date1.time = DateTimeProvider.Default.GetTime();
date1.timeutc = DateTimeProvider.Default.GetUtcNow();
this.date = date1;
this.mempool = new TxMempool(new FeeRate(1000), DateTimeProvider.Default, new BlockPolicyEstimator(new FeeRate(1000), NodeSettings.Default(), new LoggerFactory()), new LoggerFactory());;
this.mempoolLock = new MempoolAsyncLock();
// Simple block creation, nothing special yet:
this.newBlock = AssemblerForTest(this).CreateNewBlock(this.scriptPubKey);
this.chain.SetTip(this.newBlock.Block.Header);
this.consensus.AcceptBlock(new ContextInformation(new BlockResult {
Block = this.newBlock.Block
}, this.network.Consensus)
{
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);
this.consensus.AcceptBlock(new ContextInformation(new BlockResult {
Block = pblock
}, this.network.Consensus)
{
CheckPow = false, CheckMerkleRoot = false
});
blocks.Add(pblock);
}
// Just to make sure we can still make simple blocks
this.newBlock = AssemblerForTest(this).CreateNewBlock(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 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
});
}
/// <summary>
/// Creates a proof of work block assembler.
/// </summary>
/// <param name="network">Network running on.</param>
/// <param name="consensus">Consensus loop.</param>
/// <param name="chain">Block chain.</param>
/// <param name="mempoolLock">Async lock for memory pool.</param>
/// <param name="mempool">Memory pool for transactions.</param>
/// <param name="date">Date and time provider.</param>
/// <returns>Proof of work block assembler.</returns>
private static PowBlockAssembler CreatePowBlockAssembler(Network network, ConsensusLoop consensus, ConcurrentChain chain, MempoolAsyncLock mempoolLock, TxMempool mempool, IDateTimeProvider date)
{
AssemblerOptions options = new AssemblerOptions();
options.BlockMaxWeight = network.Consensus.Option <PowConsensusOptions>().MAX_BLOCK_WEIGHT;
options.BlockMaxSize = network.Consensus.Option <PowConsensusOptions>().MAX_BLOCK_SERIALIZED_SIZE;
FeeRate blockMinFeeRate = new FeeRate(PowMining.DefaultBlockMinTxFee);
options.BlockMinFeeRate = blockMinFeeRate;
Mock <ILogger> logger = new Mock <ILogger>();
return(new PowBlockAssembler(consensus, network, chain, mempoolLock, mempool, date, logger.Object, options));
}
/// <summary>
/// Creates a proof of work block assembler.
/// </summary>
/// <param name="network">Network running on.</param>
/// <param name="consensus">Consensus loop.</param>
/// <param name="chain">Block chain.</param>
/// <param name="mempoolLock">Async lock for memory pool.</param>
/// <param name="mempool">Memory pool for transactions.</param>
/// <param name="date">Date and time provider.</param>
/// <returns>Proof of work block assembler.</returns>
private static PowBlockAssembler CreatePowBlockAssembler(Network network, ConsensusLoop consensus, ConcurrentChain chain, MempoolAsyncLock mempoolLock, TxMempool mempool, IDateTimeProvider date, LoggerFactory loggerFactory)
{
AssemblerOptions options = new AssemblerOptions();
options.BlockMaxWeight = network.Consensus.Option <PowConsensusOptions>().MaxBlockWeight;
options.BlockMaxSize = network.Consensus.Option <PowConsensusOptions>().MaxBlockSerializedSize;
FeeRate blockMinFeeRate = new FeeRate(PowMining.DefaultBlockMinTxFee);
options.BlockMinFeeRate = blockMinFeeRate;
return(new PowBlockAssembler(consensus, network, mempoolLock, mempool, date, chain.Tip, loggerFactory, options));
}
