public SmartContractPosPowBlockDefinition(
IBlockBufferGenerator blockBufferGenerator,
ICoinView coinView,
IConsensusLoop consensusLoop,
IDateTimeProvider dateTimeProvider,
ISmartContractExecutorFactory executorFactory,
ILoggerFactory loggerFactory,
ITxMempool mempool,
MempoolSchedulerLock mempoolLock,
MinerSettings minerSettings,
Network network,
ISenderRetriever senderRetriever,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
IContractStateRoot stateRoot)
: base(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network)
{
this.coinView = coinView;
this.executorFactory = executorFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.senderRetriever = senderRetriever;
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
this.stateRoot = stateRoot;
// When building smart contract blocks, we will be generating and adding both transactions to the block and txouts to the coinbase.
// At the moment, these generated objects aren't accounted for in the block size and weight accounting.
// This means that if blocks started getting full, this miner could start generating blocks greater than the max consensus block size.
// To avoid this without significantly overhauling the BlockDefinition, for now we just lower the block size by a percentage buffer.
// If in the future blocks are being built over the size limit and you need an easy fix, just increase the size of this buffer.
this.Options = blockBufferGenerator.GetOptionsWithBuffer(this.Options);
}
public Unity3dController(ILoggerFactory loggerFactory, IAddressIndexer addressIndexer,
IBlockStore blockStore, IChainState chainState, Network network, ICoinView coinView, WalletController walletController, ChainIndexer chainIndexer, INFTTransferIndexer NFTTransferIndexer,
IStakeChain stakeChain = null,
IContractPrimitiveSerializer primitiveSerializer = null, IStateRepositoryRoot stateRoot = null, IContractAssemblyCache contractAssemblyCache = null,
IReceiptRepository receiptRepository = null, ISmartContractTransactionService smartContractTransactionService = null, ILocalExecutor localExecutor = null)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.addressIndexer = Guard.NotNull(addressIndexer, nameof(addressIndexer));
this.blockStore = Guard.NotNull(blockStore, nameof(blockStore));
this.chainState = Guard.NotNull(chainState, nameof(chainState));
this.network = Guard.NotNull(network, nameof(network));
this.coinView = Guard.NotNull(coinView, nameof(coinView));
this.walletController = Guard.NotNull(walletController, nameof(walletController));
this.chainIndexer = Guard.NotNull(chainIndexer, nameof(chainIndexer));
this.stakeChain = stakeChain;
this.NFTTransferIndexer = NFTTransferIndexer;
this.primitiveSerializer = primitiveSerializer;
this.stateRoot = stateRoot;
this.contractAssemblyCache = contractAssemblyCache;
this.receiptRepository = receiptRepository;
this.smartContractTransactionService = smartContractTransactionService;
this.localExecutor = localExecutor;
}
public NodeServices(DataFolder dataFolder, ChainIndexer chainIndexer, Network network,
IBroadcasterManager broadcasterManager, ILoggerFactory loggerFactory,
INodeLifetime nodeLifetime, ISignals signals, IBlockStore blockStore,
ITimeSyncBehaviorState timeSyncBehaviorState, IInitialBlockDownloadState initialBlockDownloadState,
IBlockProvider blockProvider, IConsensusManager consensusManager, IStakeChain stakeChain,
ICoinView coinView, IDateTimeProvider dateTimeProvider, IChainState chainState)
{
C.Network = network;
Log.SetLogger(loggerFactory.CreateLogger(nameof(X1Wallet)));
this.LoggerFactory = loggerFactory;
this.DataFolder = dataFolder;
this.ChainIndexer = chainIndexer;
this.BroadcasterManager = broadcasterManager;
this.NodeLifetime = nodeLifetime;
this.InitialBlockDownloadState = initialBlockDownloadState;
this.Signals = signals;
this.BlockStore = blockStore;
this.TimeSyncBehaviorState = timeSyncBehaviorState;
this.BlockProvider = blockProvider;
this.ConsensusManager = consensusManager;
this.PosCoinviewRule = consensusManager?.ConsensusRules.GetRule <PosCoinviewRule>();
this.StakeChain = stakeChain;
this.DateTimeProvider = dateTimeProvider;
this.CoinView = coinView;
this.ChainState = chainState;
}
public SmartContractPosConsensusRuleEngine(
ConcurrentChain chain,
ICheckpoints checkpoints,
ConsensusSettings consensusSettings,
IDateTimeProvider dateTimeProvider,
IContractExecutorFactory executorFactory,
ILoggerFactory loggerFactory,
Network network,
NodeDeployments nodeDeployments,
IStateRepositoryRoot originalStateRoot,
IReceiptRepository receiptRepository,
ISenderRetriever senderRetriever,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
ICoinView utxoSet,
IChainState chainState,
IInvalidBlockHashStore invalidBlockHashStore,
INodeStats nodeStats)
: base(network, loggerFactory, dateTimeProvider, chain, nodeDeployments, consensusSettings, checkpoints, utxoSet, stakeChain, stakeValidator, chainState, invalidBlockHashStore, nodeStats)
{
this.ExecutorFactory = executorFactory;
this.OriginalStateRoot = originalStateRoot;
this.ReceiptRepository = receiptRepository;
this.SenderRetriever = senderRetriever;
}
public BlockStoreController(
Network network,
ILoggerFactory loggerFactory,
IBlockStore blockStore,
IChainState chainState,
ChainIndexer chainIndexer,
IAddressIndexer addressIndexer,
IUtxoIndexer utxoIndexer,
IStakeChain stakeChain = null)
{
Guard.NotNull(network, nameof(network));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(chainState, nameof(chainState));
Guard.NotNull(addressIndexer, nameof(addressIndexer));
Guard.NotNull(utxoIndexer, nameof(utxoIndexer));
this.addressIndexer = addressIndexer;
this.network = network;
this.blockStore = blockStore;
this.chainState = chainState;
this.chainIndexer = chainIndexer;
this.utxoIndexer = utxoIndexer;
this.stakeChain = stakeChain;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public FullNodeController(
ILoggerFactory loggerFactory,
IPooledTransaction pooledTransaction = null,
IPooledGetUnspentTransaction pooledGetUnspentTransaction = null,
IGetUnspentTransaction getUnspentTransaction = null,
INetworkDifficulty networkDifficulty = null,
IFullNode fullNode = null,
NodeSettings nodeSettings = null,
Network network = null,
ChainIndexer chainIndexer = null,
IChainState chainState = null,
Connection.IConnectionManager connectionManager = null,
IConsensusManager consensusManager = null,
IBlockStore blockStore = null,
IInitialBlockDownloadState ibdState = null,
IStakeChain stakeChain = null)
: base(
fullNode: fullNode,
network: network,
nodeSettings: nodeSettings,
chainIndexer: chainIndexer,
chainState: chainState,
connectionManager: connectionManager,
consensusManager: consensusManager)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.pooledTransaction = pooledTransaction;
this.pooledGetUnspentTransaction = pooledGetUnspentTransaction;
this.getUnspentTransaction = getUnspentTransaction;
this.networkDifficulty = networkDifficulty;
this.blockStore = blockStore;
this.ibdState = ibdState;
this.stakeChain = stakeChain;
}
/// <inheritdoc />
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="stakeChain">Database of stake related data for the current blockchain.</param>
/// <param name="chain">Chain of headers.</param>
/// <param name="coinView">Used for getting UTXOs.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public StakeValidator(Network network, IStakeChain stakeChain, ConcurrentChain chain, ICoinView coinView, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
this.chain = chain;
this.coinView = coinView;
this.network = network;
}
/// <inheritdoc />
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="stakeChain">Database of stake related data for the current blockchain.</param>
/// <param name="chainIndexer">Chain of headers.</param>
/// <param name="coinView">Used for getting UTXOs.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public X1StakeValidator(Network network, IStakeChain stakeChain, ChainIndexer chainIndexer, ICoinView coinView, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
this.chainIndexer = chainIndexer;
this.coinView = coinView;
this.network = network;
}
/// <inheritdoc />
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="stakeChain">Database of stake related data for the current blockchain.</param>
/// <param name="chainIndexer">Chain of headers.</param>
/// <param name="coinView">Used for getting UTXOs.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public StakeValidator(Network network, IStakeChain stakeChain, ChainIndexer chainIndexer, ICoinView coinView, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.FullNode");
this.stakeChain = stakeChain;
this.chainIndexer = chainIndexer;
this.coinView = coinView;
this.network = network;
}
/// <inheritdoc />
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="stakeChain">Database of stake related data for the current blockchain.</param>
/// <param name="chain">Chain of headers.</param>
/// <param name="coinView">Used for getting UTXOs.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public StakeValidator(Network network, IStakeChain stakeChain, ConcurrentChain chain, CoinView coinView, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
this.chain = chain;
this.coinView = coinView;
this.consensusOptions = network.Consensus.Option <PosConsensusOptions>();
}
/// <inheritdoc />
public override void Initialize()
{
base.Initialize();
this.consensus = this.Parent.Network.Consensus;
this.smartContractPosParent = (SmartContractPosConsensusRuleEngine)this.Parent;
this.stakeChain = this.smartContractPosParent.StakeChain;
this.stakeValidator = this.smartContractPosParent.StakeValidator;
}
/// <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,
IPowConsensusValidator validator,
INodeLifetime nodeLifetime,
ConcurrentChain chain,
CoinView utxoSet,
LookaheadBlockPuller puller,
NodeDeployments nodeDeployments,
ILoggerFactory loggerFactory,
IChainState chainState,
IConnectionManager connectionManager,
IDateTimeProvider dateTimeProvider,
Signals.Signals signals,
ConsensusSettings consensusSettings,
NodeSettings nodeSettings,
IPeerBanning peerBanning,
IConsensusRules consensusRules,
IStakeChain 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;
}
/// <inheritdoc />
public Target GetNextTargetRequired(IStakeChain stakeChain, ChainedHeader chainedHeader, IConsensus consensus,
bool proofOfStake)
{
Guard.NotNull(stakeChain, nameof(stakeChain));
// Genesis block.
if (chainedHeader == null)
{
this.logger.LogTrace("(-)[GENESIS]:'{0}'", consensus.PowLimit);
return(consensus.PowLimit);
}
// Find the last two blocks that correspond to the mining algo
// (i.e if this is a POS block we need to find the last two POS blocks).
var targetLimit = proofOfStake
? consensus.ProofOfStakeLimitV2
: consensus.PowLimit.ToBigInteger();
// First block.
var lastPowPosBlock = GetLastPowPosChainedBlock(stakeChain, chainedHeader, proofOfStake);
if (lastPowPosBlock.Previous == null)
{
var res = new Target(targetLimit);
this.logger.LogTrace("(-)[FIRST_BLOCK]:'{0}'", res);
return(res);
}
// Second block.
var prevLastPowPosBlock = GetLastPowPosChainedBlock(stakeChain, lastPowPosBlock.Previous, proofOfStake);
if (prevLastPowPosBlock.Previous == null)
{
var res = new Target(targetLimit);
this.logger.LogTrace("(-)[SECOND_BLOCK]:'{0}'", res);
return(res);
}
// This is used in tests to allow quickly mining blocks.
if (!proofOfStake && consensus.PowNoRetargeting)
{
this.logger.LogTrace("(-)[NO_POW_RETARGET]:'{0}'", lastPowPosBlock.Header.Bits);
return(lastPowPosBlock.Header.Bits);
}
if (proofOfStake && consensus.PosNoRetargeting)
{
this.logger.LogTrace("(-)[NO_POS_RETARGET]:'{0}'", lastPowPosBlock.Header.Bits);
return(lastPowPosBlock.Header.Bits);
}
var finalTarget = CalculateRetarget(lastPowPosBlock.Header.Time, lastPowPosBlock.Header.Bits,
prevLastPowPosBlock.Header.Time, targetLimit);
return(finalTarget);
}
/// <inheritdoc />
public override void Initialize()
{
base.Initialize();
this.consensus = this.Parent.Network.Consensus;
var consensusRules = (PosConsensusRuleEngine)this.Parent;
this.stakeValidator = consensusRules.StakeValidator;
this.stakeChain = consensusRules.StakeChain;
}
public SmartContractPosCoinviewRule(Network network, IStateRepositoryRoot stateRepositoryRoot,
IContractExecutorFactory executorFactory, ICallDataSerializer callDataSerializer,
ISenderRetriever senderRetriever, IReceiptRepository receiptRepository, ICoinView coinView,
IStakeChain stakeChain, IStakeValidator stakeValidator)
: base(network, stateRepositoryRoot, executorFactory, callDataSerializer, senderRetriever, receiptRepository, coinView)
{
this.consensus = network.Consensus;
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
}
public PosTestBlockAssembler(
IConsensusLoop consensusLoop,
Network network,
MempoolSchedulerLock mempoolLock,
ITxMempool mempool,
IDateTimeProvider dateTimeProvider,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
ILoggerFactory loggerFactory)
: base(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, network, stakeChain, stakeValidator)
{
base.block = this.BlockTemplate.Block;
}
/// <inheritdoc/>
public ChainedHeader GetLastPowPosChainedBlock(IStakeChain stakeChain, ChainedHeader startChainedHeader, bool proofOfStake)
{
Guard.Assert(startChainedHeader != null);
BlockStake blockStake = stakeChain.Get(startChainedHeader.HashBlock);
while ((startChainedHeader.Previous != null) && (blockStake.IsProofOfStake() != proofOfStake))
{
startChainedHeader = startChainedHeader.Previous;
blockStake = stakeChain.Get(startChainedHeader.HashBlock);
}
return(startChainedHeader);
}
/// <inheritdoc />
public override void Initialize()
{
this.Logger.LogTrace("()");
base.Initialize();
var consensusRules = (PosConsensusRules)this.Parent;
this.stakeValidator = consensusRules.StakeValidator;
this.stakeChain = consensusRules.StakeChain;
this.posConsensusOptions = this.Parent.ConsensusParams.Option <PosConsensusOptions>();
this.Logger.LogTrace("(-)");
}
/// <inheritdoc />
public override void Initialize()
{
this.Logger.LogTrace("()");
base.Initialize();
this.consensus = this.Parent.Network.Consensus;
var consensusRules = (PosConsensusRules)this.Parent;
this.stakeValidator = consensusRules.StakeValidator;
this.stakeChain = consensusRules.StakeChain;
this.Logger.LogTrace("(-)");
}
public PosTestBlockAssembler(IConsensusLoop consensusLoop,
Network network,
MempoolSchedulerLock mempoolLock,
ITxMempool mempool,
IDateTimeProvider dateTimeProvider,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
ChainedBlock chainTip,
ILoggerFactory loggerFactory,
AssemblerOptions options = null) :
base(consensusLoop, network, mempoolLock, mempool, dateTimeProvider, stakeChain, stakeValidator, chainTip, loggerFactory, options)
{
base.pblock = this.pblocktemplate.Block;
}
public PosTestBlockAssembler(
IConsensusManager consensusManager,
Network network,
MempoolSchedulerLock mempoolLock,
ITxMempool mempool,
MinerSettings minerSettings,
IDateTimeProvider dateTimeProvider,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
ILoggerFactory loggerFactory,
NodeDeployments nodeDeployments)
: base(consensusManager, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network, stakeChain, stakeValidator, nodeDeployments)
{
base.block = this.BlockTemplate.Block;
}
public PosPowBlockDefinition(
IConsensusLoop consensusLoop,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ITxMempool mempool,
MempoolSchedulerLock mempoolLock,
Network network,
IStakeChain stakeChain,
IStakeValidator stakeValidator)
: base(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, network, new BlockDefinitionOptions() { IsProofOfStake = false })
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
}
/// <inheritdoc />
public ChainedHeader GetLastPowPosChainedBlock(IStakeChain stakeChain, ChainedHeader startChainedHeader,
bool proofOfStake)
{
Guard.NotNull(stakeChain, nameof(stakeChain));
Guard.Assert(startChainedHeader != null);
var blockStake = stakeChain.Get(startChainedHeader.HashBlock);
while (startChainedHeader.Previous != null && blockStake.IsProofOfStake() != proofOfStake)
{
startChainedHeader = startChainedHeader.Previous;
blockStake = stakeChain.Get(startChainedHeader.HashBlock);
}
return(startChainedHeader);
}
/// <inheritdoc />
/// <param name="stakeValidator">Provides functionality for checking validity of PoS blocks.</param>
/// <param name="checkpoints">Provider of block header hash checkpoints.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="stakeChain">Database of stake related data for the current blockchain.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
public PosConsensusValidator(
IStakeValidator stakeValidator,
ICheckpoints checkpoints,
Network network,
IStakeChain stakeChain,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory)
: base(network, checkpoints, dateTimeProvider, loggerFactory)
{
Guard.NotNull(network.Consensus.Option <PosConsensusOptions>(), nameof(network.Consensus.Options));
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.StakeValidator = stakeValidator;
this.stakeChain = stakeChain;
this.consensusOptions = network.Consensus.Option <PosConsensusOptions>();
}
public PosPowBlockDefinition(
IConsensusManager consensusManager,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ITxMempool mempool,
MempoolSchedulerLock mempoolLock,
Network network,
MinerSettings minerSettings,
IStakeChain stakeChain,
IStakeValidator stakeValidator)
: base(consensusManager, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network)
{
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.Fullnode");
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
}
public PosBlockDefinition(
IConsensusManager consensusManager,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ITxMempool mempool,
MempoolSchedulerLock mempoolLock,
MinerSettings minerSettings,
Network network,
IStakeChain stakeChain,
IStakeValidator stakeValidator)
: base(consensusManager, dateTimeProvider, loggerFactory, mempool, mempoolLock, minerSettings, network)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.stakeChain = stakeChain;
this.stakeValidator = stakeValidator;
}
/// <inheritdoc/>
public Target GetNextTargetRequired(IStakeChain stakeChain, ChainedHeader chainedHeader, NBitcoin.Consensus consensus, bool proofOfStake)
{
this.logger.LogTrace("({0}:'{1}',{2}:{3})", nameof(chainedHeader), chainedHeader, nameof(proofOfStake), proofOfStake);
// Genesis block.
if (chainedHeader == null)
{
this.logger.LogTrace("(-)[GENESIS]:'{0}'", consensus.PowLimit);
return consensus.PowLimit;
}
// Find the last two blocks that correspond to the mining algo
// (i.e if this is a POS block we need to find the last two POS blocks).
BigInteger targetLimit = proofOfStake
? consensus.ProofOfStakeLimitV2
: consensus.PowLimit.ToBigInteger();
// First block.
ChainedHeader lastPowPosBlock = this.GetLastPowPosChainedBlock(stakeChain, chainedHeader, proofOfStake);
if (lastPowPosBlock.Previous == null)
{
var res = new Target(targetLimit);
this.logger.LogTrace("(-)[FIRST_BLOCK]:'{0}'", res);
return res;
}
// Second block.
ChainedHeader prevLastPowPosBlock = this.GetLastPowPosChainedBlock(stakeChain, lastPowPosBlock.Previous, proofOfStake);
if (prevLastPowPosBlock.Previous == null)
{
var res = new Target(targetLimit);
this.logger.LogTrace("(-)[SECOND_BLOCK]:'{0}'", res);
return res;
}
// This is used in tests to allow quickly mining blocks.
if (consensus.PowNoRetargeting)
{
this.logger.LogTrace("(-)[NO_POW_RETARGET]:'{0}'", lastPowPosBlock.Header.Bits);
return lastPowPosBlock.Header.Bits;
}
Target finalTarget = this.CalculateRetarget(lastPowPosBlock.Header.Time, lastPowPosBlock.Header.Bits, prevLastPowPosBlock.Header.Time, targetLimit);
this.logger.LogTrace("(-):'{0}'", finalTarget);
return finalTarget;
}
/// <inheritdoc/>
public ChainedHeader GetLastPowPosChainedBlock(IStakeChain stakeChain, ChainedHeader startChainedHeader, bool proofOfStake)
{
Guard.Assert(startChainedHeader != null);
this.logger.LogTrace("({0}:'{1}',{2}:{3})", nameof(startChainedHeader), startChainedHeader, nameof(proofOfStake), proofOfStake);
BlockStake blockStake = stakeChain.Get(startChainedHeader.HashBlock);
while ((startChainedHeader.Previous != null) && (blockStake.IsProofOfStake() != proofOfStake))
{
startChainedHeader = startChainedHeader.Previous;
blockStake = stakeChain.Get(startChainedHeader.HashBlock);
}
this.logger.LogTrace("(-)':{0}'", startChainedHeader);
return(startChainedHeader);
}
public PosBlockAssembler(
IConsensusLoop consensusLoop,
Network network,
MempoolSchedulerLock mempoolLock,
ITxMempool mempool,
IDateTimeProvider dateTimeProvider,
IStakeChain stakeChain,
IStakeValidator stakeValidator,
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;
this.stakeValidator = stakeValidator;
}
public PowAssemblerFactory(
IConsensusLoop consensusLoop,
Network network,
MempoolSchedulerLock mempoolLock,
ITxMempool mempool,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
IStakeChain stakeChain = null)
{
this.consensusLoop = consensusLoop;
this.network = network;
this.mempoolLock = mempoolLock;
this.mempool = mempool;
this.dateTimeProvider = dateTimeProvider;
this.stakeChain = stakeChain;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
