public void Reseal_generated_transactions()
{
ITxSource innerSource = Substitute.For <ITxSource>();
ITxSealer txSealer = Substitute.For <ITxSealer>();
IStateReader stateReader = Substitute.For <IStateReader>();
BlockHeader parent = Build.A.BlockHeader.TestObject;
long gasLimit = long.MaxValue;
Transaction poolTx = Build.A.Transaction.WithSenderAddress(TestItem.AddressA).TestObject;
GeneratedTransaction generatedTx = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressB).TestObject;
innerSource.GetTransactions(parent, gasLimit).Returns(new[] { poolTx, generatedTx });
var txSource = new GeneratedTxSource(innerSource, txSealer, stateReader, LimboLogs.Instance);
txSource.GetTransactions(parent, gasLimit).ToArray();
txSealer.Received().Seal(generatedTx, TxHandlingOptions.ManagedNonce | TxHandlingOptions.AllowReplacingSignature);
txSealer.DidNotReceive().Seal(poolTx, Arg.Any <TxHandlingOptions>());
}
public void transactions_are_addable_to_block_after_sealing()
{
int chainId = 5;
var blockHeader = Build.A.BlockHeader.TestObject;
var tx1 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
var tx2 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
var timestamper = Substitute.For <ITimestamper>();
var stateReader = Substitute.For <IStateReader>();
var nodeAddress = TestItem.AddressA;
UInt256 expectedNonce = 10;
stateReader.GetNonce(blockHeader.StateRoot, nodeAddress).Returns(expectedNonce);
ulong expectedTimeStamp = 100;
timestamper.UnixTime.Returns(UnixTime.FromSeconds(expectedTimeStamp));
var gasLimit = 200;
var innerTxSource = Substitute.For <ITxSource>();
innerTxSource.GetTransactions(blockHeader, gasLimit).Returns(new[] { tx1, tx2 });
TxSealer txSealer = new TxSealer(new Signer((ulong)chainId, Build.A.PrivateKey.TestObject, LimboLogs.Instance), timestamper);
var transactionFiller = new GeneratedTxSource(innerTxSource, txSealer, stateReader, LimboLogs.Instance);
var sealedTxs = transactionFiller.GetTransactions(blockHeader, gasLimit).ToArray();
var sealedTx1 = sealedTxs.First();
var sealedTx2 = sealedTxs.Skip(1).First();
sealedTx1.IsSigned.Should().BeTrue();
sealedTx1.Nonce.Should().Be(expectedNonce);
sealedTx1.Hash.Should().Be(tx1.CalculateHash());
sealedTx1.Timestamp.Should().Be(expectedTimeStamp);
sealedTx2.IsSigned.Should().BeTrue();
sealedTx2.Nonce.Should().Be(expectedNonce + 1);
sealedTx2.Hash.Should().NotBe(tx1.CalculateHash());
sealedTx2.Timestamp.Should().Be(expectedTimeStamp);
}
protected override ITxSource CreateTxSourceForProducer(ReadOnlyTxProcessingEnv processingEnv, IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
bool CheckAddPosdaoTransactions(IList <ITxSource> list, long auRaPosdaoTransition)
{
if (auRaPosdaoTransition < AuRaParameters.TransitionDisabled && _validator is ITxSource validatorSource)
{
list.Insert(0, validatorSource);
return(true);
}
return(false);
}
bool CheckAddRandomnessTransactions(IList <ITxSource> list, IDictionary <long, Address>?randomnessContractAddress, ISigner signer)
{
IList <IRandomContract> GetRandomContracts(
IDictionary <long, Address> randomnessContractAddressPerBlock,
IAbiEncoder abiEncoder,
IReadOnlyTxProcessorSource txProcessorSource,
ISigner signerLocal) =>
randomnessContractAddressPerBlock
.Select(kvp => new RandomContract(
abiEncoder,
kvp.Value,
txProcessorSource,
kvp.Key,
signerLocal))
.ToArray <IRandomContract>();
if (randomnessContractAddress?.Any() == true)
{
var randomContractTxSource = new RandomContractTxSource(
GetRandomContracts(randomnessContractAddress, _api.AbiEncoder,
readOnlyTxProcessorSource,
signer),
new EciesCipher(_api.CryptoRandom),
signer,
_api.NodeKey,
_api.CryptoRandom,
_api.LogManager);
list.Insert(0, randomContractTxSource);
return(true);
}
return(false);
}
if (_api.ChainSpec == null)
{
throw new StepDependencyException(nameof(_api.ChainSpec));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.EngineSigner == null)
{
throw new StepDependencyException(nameof(_api.EngineSigner));
}
IList <ITxSource> txSources = new List <ITxSource> {
base.CreateTxSourceForProducer(processingEnv, readOnlyTxProcessorSource)
};
bool needSigner = false;
needSigner |= CheckAddPosdaoTransactions(txSources, _api.ChainSpec.AuRa.PosdaoTransition);
needSigner |= CheckAddRandomnessTransactions(txSources, _api.ChainSpec.AuRa.RandomnessContractAddress, _api.EngineSigner);
ITxSource txSource = txSources.Count > 1 ? new CompositeTxSource(txSources.ToArray()) : txSources[0];
if (needSigner)
{
TxSealer transactionSealer = new TxSealer(_api.EngineSigner, _api.Timestamper);
txSource = new GeneratedTxSource(txSource, transactionSealer, processingEnv.StateReader, _api.LogManager);
}
if (_txPermissionFilter != null)
{
// we now only need to filter generated transactions here, as regular ones are filtered on TxPoolTxSource filter based on CreateTxSourceFilter method
txSource = new FilteredTxSource <GeneratedTransaction>(txSource, _txPermissionFilter, _api.LogManager);
}
return(txSource);
}
