public void AddTransactions_TransactionAlreadyInInblock_DoesNotAddTransactionToBlock()
{
var newOptions = new PosConsensusOptions()
{
MaxBlockWeight = 1500
};
this.ExecuteWithConsensusOptions(newOptions, () =>
{
var chain = GenerateChainWithHeight(5, this.network, this.key);
this.consensusLoop.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
var transaction = CreateTransaction(this.network, this.key, 5, new Money(400 * 1000 * 1000), new Key(), new uint256(124124));
var txFee = new Money(1000);
var entries = SetupTxMempool(chain, newOptions, txFee, transaction);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object);
posBlockAssembler.AddInBlockTxEntries(entries);
var result = posBlockAssembler.AddTransactions();
Assert.Empty(result.Block.Transactions);
Assert.Equal(0, result.Selected);
Assert.Equal(0, result.Updated);
});
}
public void CreateCoinbase_CreatesCoinbaseTemplateTransaction_AddsToBlockTemplate()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
ChainIndexer chainIndexer = GenerateChainWithHeight(5, this.Network, this.key);
this.dateTimeProvider.Setup(d => d.GetAdjustedTimeAsUnixTimestamp())
.Returns(new DateTime(2017, 1, 7, 0, 0, 1, DateTimeKind.Utc).ToUnixTimestamp());
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.Network, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object, new NodeDeployments(this.Network, chainIndexer));
BlockTemplate result = posBlockAssembler.CreateCoinBase(chainIndexer.Tip, this.key.ScriptPubKey);
Assert.NotEmpty(result.Block.Transactions);
Transaction resultingTransaction = result.Block.Transactions[0];
// Creating a coinbase will not by itself update the header timestamp. So we don't check that here.
Assert.True(resultingTransaction.IsCoinBase);
Assert.False(resultingTransaction.IsCoinStake);
Assert.Equal(Money.Zero, resultingTransaction.TotalOut);
Assert.NotEmpty(resultingTransaction.Inputs);
Assert.Equal(TxIn.CreateCoinbase(6).ScriptSig, resultingTransaction.Inputs[0].ScriptSig);
Assert.NotEmpty(resultingTransaction.Outputs);
Assert.Equal(this.key.ScriptPubKey, resultingTransaction.Outputs[0].ScriptPubKey);
Assert.Equal(Money.Zero, resultingTransaction.Outputs[0].Value);
});
}
public void UpdateHeaders_UsingChainAndNetwork_PreparesStakeBlockHeaders()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
this.dateTimeProvider.Setup(d => d.GetTimeOffset())
.Returns(new DateTimeOffset(new DateTime(2017, 1, 7, 0, 0, 0, DateTimeKind.Utc)));
var chain = GenerateChainWithHeight(5, this.network, new Key());
var assemblerOptions = new AssemblerOptions()
{
IsProofOfStake = true
};
this.stakeValidator.Setup(s => s.GetNextTargetRequired(this.stakeChain.Object, chain.Tip, this.network.Consensus, true))
.Returns(new Target(new uint256(1123123123)))
.Verifiable();
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object, assemblerOptions);
var result = posBlockAssembler.UpdateHeaders(chain.Tip);
Assert.Equal(chain.Tip.HashBlock, result.Header.HashPrevBlock);
Assert.Equal((uint)1483747200, result.Header.Time);
Assert.Equal(2.400408204198463E+58, result.Header.Bits.Difficulty);
Assert.Equal((uint)0, result.Header.Nonce);
this.stakeValidator.Verify();
});
}
public void CreateCoinbase_CreatesCoinbaseTemplateTransaction_AddsToBlockTemplate()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, this.key);
this.dateTimeProvider.Setup(d => d.GetAdjustedTimeAsUnixTimestamp())
.Returns(new DateTime(2017, 1, 7, 0, 0, 1, DateTimeKind.Utc).ToUnixTimestamp());
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
BlockTemplate result = posBlockAssembler.CreateCoinBase(chain.Tip, this.key.ScriptPubKey);
Assert.NotEmpty(result.Block.Transactions);
Transaction resultingTransaction = result.Block.Transactions[0];
Assert.Equal((uint)new DateTime(2017, 1, 7, 0, 0, 1, DateTimeKind.Utc).ToUnixTimestamp(), resultingTransaction.Time);
Assert.True(resultingTransaction.IsCoinBase);
Assert.False(resultingTransaction.IsCoinStake);
Assert.Equal(Money.Zero, resultingTransaction.TotalOut);
Assert.NotEmpty(resultingTransaction.Inputs);
Assert.Equal(TxIn.CreateCoinbase(6).ScriptSig, resultingTransaction.Inputs[0].ScriptSig);
Assert.NotEmpty(resultingTransaction.Outputs);
Assert.Equal(this.key.ScriptPubKey, resultingTransaction.Outputs[0].ScriptPubKey);
Assert.Equal(Money.Zero, resultingTransaction.Outputs[0].Value);
});
}
public void AddTransactions_TransactionNotInblock_AddsTransactionToBlock()
{
var newOptions = new PosConsensusOptions()
{
MaxBlockWeight = 1500
};
this.ExecuteWithConsensusOptions(newOptions, () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, this.key);
this.consensusLoop.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
Transaction transaction = CreateTransaction(this.stratisTest, this.key, 5, new Money(400 * 1000 * 1000), new Key(), new uint256(124124));
var txFee = new Money(1000);
SetupTxMempool(chain, newOptions, txFee, transaction);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
(Block Block, int Selected, int Updated)result = posBlockAssembler.AddTransactions();
Assert.NotEmpty(result.Block.Transactions);
Assert.Equal(transaction.ToHex(), result.Block.Transactions[0].ToHex());
Assert.Equal(1, result.Selected);
Assert.Equal(0, result.Updated);
});
}
public void AddTransactions_WithoutTransactionsInMempool_DoesNotAddEntriesToBlock()
{
var newOptions = new PosConsensusOptions()
{
MaxBlockWeight = 1500
};
this.ExecuteWithConsensusOptions(newOptions, () =>
{
var chain = GenerateChainWithHeight(5, this.network, new Key());
this.consensusLoop.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
var indexedTransactionSet = new TxMempool.IndexedTransactionSet();
this.txMempool.Setup(t => t.MapTx)
.Returns(indexedTransactionSet);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object);
var result = posBlockAssembler.AddTransactions();
Assert.Empty(result.Block.Transactions);
Assert.Equal(0, result.Selected);
Assert.Equal(0, result.Updated);
});
}
public void CreateCoinbase_CreatesCoinbaseTemplateTransaction_AddsToBlockTemplate()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
var chain = GenerateChainWithHeight(5, this.network, this.key);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object);
var result = posBlockAssembler.CreateCoinBase(chain.Tip, this.key.ScriptPubKey);
Assert.NotEmpty(result.Block.Transactions);
Assert.Equal(-1, result.TxSigOpsCost[0]);
Assert.Equal(new Money(-1), result.VTxFees[0]);
var resultingTransaction = result.Block.Transactions[0];
Assert.True(resultingTransaction.IsCoinBase);
Assert.False(resultingTransaction.IsCoinStake);
Assert.Equal(Money.Zero, resultingTransaction.TotalOut);
Assert.NotEmpty(resultingTransaction.Inputs);
Assert.Equal(TxIn.CreateCoinbase(6).ScriptSig, resultingTransaction.Inputs[0].ScriptSig);
Assert.NotEmpty(resultingTransaction.Outputs);
Assert.Equal(this.key.ScriptPubKey, resultingTransaction.Outputs[0].ScriptPubKey);
Assert.Equal(Money.Zero, resultingTransaction.Outputs[0].Value);
});
}
public void ComputeBlockVersion_UsingChainTipAndConsensus_NoBip9DeploymentActive_UpdatesHeightAndVersion()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
var chain = GenerateChainWithHeight(5, this.network, new Key());
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object);
var result = posBlockAssembler.ComputeBlockVersion(chain.GetBlock(4));
Assert.Equal(5, result.Height);
uint version = ThresholdConditionCache.VersionbitsTopBits;
Assert.Equal((int)version, result.Version);
});
}
public void ComputeBlockVersion_UsingChainTipAndConsensus_NoBip9DeploymentActive_UpdatesHeightAndVersion()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, new Key());
this.SetupRulesEngine(chain);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
(int Height, int Version)result = posBlockAssembler.ComputeBlockVersion(chain.GetBlock(4));
Assert.Equal(5, result.Height);
Assert.Equal((int)ThresholdConditionCache.VersionbitsTopBits, result.Version);
});
}
public void TestBlockValidity_DoesNotValidateBlockUsingRuleContext()
{
var newOptions = new PosConsensusOptions()
{
MaxBlockWeight = 1500
};
this.ExecuteWithConsensusOptions(newOptions, () =>
{
var chain = GenerateChainWithHeight(5, this.network, new Key());
this.consensusLoop.Setup(c => c.Tip).Returns(chain.GetBlock(5));
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.mempool.Object, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
posBlockAssembler.OnTestBlockValidity();
this.consensusLoop.Verify(c => c.ValidateBlock(It.IsAny <RuleContext>()), Times.Exactly(0));
});
}
public void ComputeBlockVersion_UsingChainTipAndConsensus_Bip9DeploymentActive_UpdatesHeightAndVersion()
{
ConsensusOptions options = this.stratisTest.Consensus.Options;
int minerConfirmationWindow = this.stratisTest.Consensus.MinerConfirmationWindow;
int ruleChangeActivationThreshold = this.stratisTest.Consensus.RuleChangeActivationThreshold;
try
{
var newOptions = new PosConsensusOptions();
this.stratisTest.Consensus.Options = newOptions;
this.stratisTest.Consensus.BIP9Deployments[0] = new BIP9DeploymentsParameters(19,
new DateTimeOffset(new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
new DateTimeOffset(new DateTime(2018, 1, 1, 0, 0, 0, DateTimeKind.Utc)));
// As we are effectively using StratisTest the other deployments need to be disabled
this.stratisTest.Consensus.BIP9Deployments[BIP9Deployments.CSV] = null;
this.stratisTest.Consensus.BIP9Deployments[BIP9Deployments.Segwit] = null;
this.stratisTest.Consensus.MinerConfirmationWindow = 2;
this.stratisTest.Consensus.RuleChangeActivationThreshold = 2;
ConcurrentChain chain = GenerateChainWithHeightAndActivatedBip9(5, this.stratisTest, new Key(), this.stratisTest.Consensus.BIP9Deployments[0]);
this.SetupRulesEngine(chain);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings.Object, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
(int Height, int Version)result = posBlockAssembler.ComputeBlockVersion(chain.GetBlock(4));
Assert.Equal(5, result.Height);
int expectedVersion = (int)(ThresholdConditionCache.VersionbitsTopBits | (((uint)1) << 19));
Assert.Equal(expectedVersion, result.Version);
Assert.NotEqual((int)ThresholdConditionCache.VersionbitsTopBits, result.Version);
}
finally
{
// This is a static in the global context so be careful updating it. I'm resetting it after being done testing so I don't influence other tests.
this.stratisTest.Consensus.Options = options;
this.stratisTest.Consensus.BIP9Deployments[0] = null;
this.stratisTest.Consensus.MinerConfirmationWindow = minerConfirmationWindow;
this.stratisTest.Consensus.RuleChangeActivationThreshold = ruleChangeActivationThreshold;
}
}
public void ComputeBlockVersion_UsingChainTipAndConsensus_Bip9DeploymentActive_UpdatesHeightAndVersion()
{
ConsensusOptions options = this.stratisTest.Consensus.Options;
int minerConfirmationWindow = this.stratisTest.Consensus.MinerConfirmationWindow;
try
{
var newOptions = new PosConsensusOptions();
this.stratisTest.Consensus.Options = newOptions;
// Set the BIP9 activation to expire one day from now so that it is still signaled in the blocks.
this.stratisTest.Consensus.BIP9Deployments[0] = new BIP9DeploymentsParameters("Test", 19,
new DateTimeOffset(new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
new DateTimeOffset(DateTime.UtcNow + TimeSpan.FromDays(1)),
2);
this.stratisTest.Consensus.MinerConfirmationWindow = 2;
ChainIndexer chainIndexer = GenerateChainWithHeightAndActivatedBip9(5, this.stratisTest, new Key(), this.stratisTest.Consensus.BIP9Deployments[0]);
this.SetupRulesEngine(chainIndexer);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object, new NodeDeployments(this.Network, chainIndexer));
(int Height, int Version)result = posBlockAssembler.ComputeBlockVersion(chainIndexer.GetHeader(4));
Assert.Equal(5, result.Height);
int expectedVersion = (int)(ThresholdConditionCache.VersionbitsTopBits | (((uint)1) << 19));
Assert.Equal(expectedVersion, result.Version);
Assert.NotEqual((int)ThresholdConditionCache.VersionbitsTopBits, result.Version);
}
finally
{
// This is a static in the global context so be careful updating it. I'm resetting it after being done testing so I don't influence other tests.
this.stratisTest.Consensus.Options = options;
this.stratisTest.Consensus.BIP9Deployments[0] = null;
this.stratisTest.Consensus.MinerConfirmationWindow = minerConfirmationWindow;
}
}
public void ComputeBlockVersion_UsingChainTipAndConsensus_Bip9DeploymentActive_UpdatesHeightAndVersion()
{
var options = this.network.Consensus.Options;
var minerConfirmationWindow = this.network.Consensus.MinerConfirmationWindow;
var ruleChangeActivationThreshold = this.network.Consensus.RuleChangeActivationThreshold;
try
{
var newOptions = new PosConsensusOptions();
this.network.Consensus.Options = newOptions;
this.network.Consensus.BIP9Deployments[0] = new BIP9DeploymentsParameters(19,
new DateTimeOffset(new DateTime(2016, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
new DateTimeOffset(new DateTime(2018, 1, 1, 0, 0, 0, DateTimeKind.Utc)));
this.network.Consensus.MinerConfirmationWindow = 2;
this.network.Consensus.RuleChangeActivationThreshold = 2;
var chain = GenerateChainWithHeightAndActivatedBip9(5, this.network, new Key(), this.network.Consensus.BIP9Deployments[0]);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusLoop.Object, this.network, new MempoolSchedulerLock(), this.txMempool.Object,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, chain.Tip, this.LoggerFactory.Object);
var result = posBlockAssembler.ComputeBlockVersion(chain.GetBlock(4));
Assert.Equal(5, result.Height);
uint version = ThresholdConditionCache.VersionbitsTopBits;
int expectedVersion = (int)(version |= (((uint)1) << 19));
Assert.Equal(expectedVersion, result.Version);
Assert.NotEqual((int)ThresholdConditionCache.VersionbitsTopBits, result.Version);
}
finally
{
// This is a static in the global context so be careful updating it. I'm resetting it after being done testing so I don't influence other tests.
this.network.Consensus.Options = options;
this.network.Consensus.BIP9Deployments[0] = null;
this.network.Consensus.MinerConfirmationWindow = minerConfirmationWindow;
this.network.Consensus.RuleChangeActivationThreshold = ruleChangeActivationThreshold;
}
}
public void AddTransactions_TransactionAlreadyInInblock_DoesNotAddTransactionToBlock()
{
var newOptions = new PosConsensusOptions();
this.ExecuteWithConsensusOptions(newOptions, () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, this.key);
this.consensusManager.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
Transaction transaction = CreateTransaction(this.stratisTest, this.key, 5, new Money(400 * 1000 * 1000), new Key(), new uint256(124124));
var txFee = new Money(1000);
TxMempoolEntry[] entries = SetupTxMempool(chain, newOptions, txFee, transaction);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
posBlockAssembler.AddInBlockTxEntries(entries);
(Block Block, int Selected, int Updated)result = posBlockAssembler.AddTransactions();
Assert.Empty(result.Block.Transactions);
Assert.Equal(0, result.Selected);
Assert.Equal(0, result.Updated);
});
}
public void AddTransactions_WithoutTransactionsInMempool_DoesNotAddEntriesToBlock()
{
var newOptions = new PosConsensusOptions();
this.ExecuteWithConsensusOptions(newOptions, () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, new Key());
this.consensusManager.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
var indexedTransactionSet = new TxMempool.IndexedTransactionSet();
this.mempool.Setup(t => t.MapTx)
.Returns(indexedTransactionSet);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings,
this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
(Block Block, int Selected, int Updated)result = posBlockAssembler.AddTransactions();
Assert.Empty(result.Block.Transactions);
Assert.Equal(0, result.Selected);
Assert.Equal(0, result.Updated);
});
}
public void UpdateHeaders_UsingChainAndNetwork_PreparesStakeBlockHeaders()
{
this.ExecuteWithConsensusOptions(new PosConsensusOptions(), () =>
{
this.dateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 1, 7, 0, 0, 0, DateTimeKind.Utc)));
ChainIndexer chainIndexer = GenerateChainWithHeight(5, this.stratisTest, new Key());
this.stakeValidator.Setup(s => s.GetNextTargetRequired(this.stakeChain.Object, chainIndexer.Tip, this.stratisTest.Consensus, true))
.Returns(new Target(new uint256(1123123123)))
.Verifiable();
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object, new NodeDeployments(this.Network, chainIndexer));
Block block = posBlockAssembler.UpdateHeaders(chainIndexer.Tip);
Assert.Equal(chainIndexer.Tip.HashBlock, block.Header.HashPrevBlock);
Assert.Equal((uint)1483747200, block.Header.Time);
Assert.Equal(2.400408204198463E+58, block.Header.Bits.Difficulty);
Assert.Equal((uint)0, block.Header.Nonce);
this.stakeValidator.Verify();
});
}
public void AddTransactions_TransactionNotInblock_AddsTransactionToBlock()
{
var newOptions = new PosConsensusOptions();
this.ExecuteWithConsensusOptions(newOptions, () =>
{
ConcurrentChain chain = GenerateChainWithHeight(5, this.stratisTest, this.key);
this.consensusManager.Setup(c => c.Tip)
.Returns(chain.GetBlock(5));
Mock <IConsensusRuleEngine> consensusRuleEngine = new Mock <IConsensusRuleEngine>();
consensusRuleEngine.Setup(s => s.GetRule <PosFutureDriftRule>()).Returns(new PosFutureDriftRule());
this.consensusManager.Setup(c => c.ConsensusRules)
.Returns(consensusRuleEngine.Object);
Transaction transaction = CreateTransaction(this.stratisTest, this.key, 5, new Money(400 * 1000 * 1000), new Key(), new uint256(124124));
this.dateTimeProvider.Setup(s => s.GetAdjustedTimeAsUnixTimestamp()).Returns(transaction.Time);
var txFee = new Money(1000);
SetupTxMempool(chain, newOptions, txFee, transaction);
var posBlockAssembler = new PosTestBlockAssembler(this.consensusManager.Object, this.stratisTest, new MempoolSchedulerLock(), this.mempool.Object, this.minerSettings, this.dateTimeProvider.Object, this.stakeChain.Object, this.stakeValidator.Object, this.LoggerFactory.Object);
posBlockAssembler.CreateCoinBase(new ChainedHeader(this.stratisTest.GetGenesis().Header, this.stratisTest.GetGenesis().Header.GetHash(), 0), new KeyId().ScriptPubKey);
(Block Block, int Selected, int Updated)result = posBlockAssembler.AddTransactions();
Assert.NotEmpty(result.Block.Transactions);
Assert.Equal(transaction.ToHex(), result.Block.Transactions[1].ToHex());
Assert.Equal(1, result.Selected);
Assert.Equal(0, result.Updated);
});
}
