private void TimerOnElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
{
_timer.Interval = RandomizeDelay().TotalMilliseconds;
_logger.Debug($"Generating a test transaction for testing ({_count}).");
Transaction tx = new Transaction();
tx.GasPrice = 1;
tx.GasLimit = 21000;
tx.To = new Address(0x0f.ToBigEndianByteArray().PadLeft(20));
tx.Nonce = _nonce++;
tx.Value = 1;
tx.Data = new byte[0];
tx.Nonce = _count++;
tx.SenderAddress = SenderAddress;
_ecdsa.Sign(_privateKey, tx, 1);
Address address = _ecdsa.RecoverAddress(tx, 1);
if (address != tx.SenderAddress)
{
throw new InvalidDataException($"{nameof(TestTransactionsGenerator)} producing invalid transactions");
}
tx.Hash = Transaction.CalculateHash(tx);
_transactionPool.AddTransaction(tx, 1);
_logger.Debug($"Generated a test transaction for testing ({_count - 1}).");
}
public Address GetBlockSealer(BlockHeader header)
{
if (header.Author != null)
{
return(header.Author);
}
if (header.Number == UInt256.Zero)
{
return(Address.Zero);
}
if (_signatures.Get(header.Hash) != null)
{
return(_signatures.Get(header.Hash));
}
int extraSeal = 65;
// Retrieve the signature from the header extra-data
if (header.ExtraData.Length < extraSeal)
{
throw new BlockchainException($"Clique block without sealer extra data{Environment.NewLine}{header.ToString(BlockHeader.Format.Full)}");
}
var signatureBytes = header.ExtraData.AsSpan().Slice(header.ExtraData.Length - extraSeal, extraSeal);
Signature signature = new Signature(signatureBytes);
signature.V += Signature.VOffset;
Keccak message = CalculateCliqueHeaderHash(header);
Address address = _ecdsa.RecoverAddress(signature, message);
_signatures.Set(header.Hash, address);
return(address);
}
public Address GetBlockSealer(BlockHeader header)
{
if (header.Author != null)
{
return(header.Author);
}
if (header.Number == UInt256.Zero)
{
return(Address.Zero);
}
if (_signatures.Get(header.Hash) != null)
{
return(_signatures.Get(header.Hash));
}
int extraSeal = 65;
// Retrieve the signature from the header extra-data
if (header.ExtraData.Length < extraSeal)
{
return(null);
}
var signatureBytes = header.ExtraData.AsSpan().Slice(header.ExtraData.Length - extraSeal, extraSeal);
Signature signature = new Signature(signatureBytes);
signature.V += Signature.VOffset;
Keccak message = CalculateCliqueHeaderHash(header);
Address address = _ecdsa.RecoverAddress(signature, message);
_signatures.Set(header.Hash, address);
return(address);
}
public void RecoverData(Block block)
{
if (block.Transactions.Length == 0 || block.Transactions[0].SenderAddress != null)
{
return;
}
var releaseSpec = _specProvider.GetSpec(block.Number);
for (int i = 0; i < block.Transactions.Length; i++)
{
Transaction blockTransaction = block.Transactions[i];
_txPool.TryGetPendingTransaction(blockTransaction.Hash, out var transaction);
Address sender = transaction?.SenderAddress;
Address blockTransactionAddress = blockTransaction.SenderAddress;
blockTransaction.SenderAddress = sender ?? _ecdsa.RecoverAddress(blockTransaction, !releaseSpec.ValidateChainId);
if (_logger.IsTrace)
{
_logger.Trace($"Recovered {blockTransaction.SenderAddress} sender for {blockTransaction.Hash} (tx pool cached value: {sender}, block transaction address: {blockTransactionAddress})");
}
}
}
private Address GetSealer(BlockHeader header)
{
Signature signature = new Signature(header.AuRaSignature);
signature.V += Signature.VOffset;
Keccak message = header.CalculateHash(RlpBehaviors.ForSealing);
return(_ecdsa.RecoverAddress(signature, message));
}
public AddTxResult AddTransaction(Transaction transaction, long blockNumber, bool doNotEvict = false)
{
Metrics.PendingTransactionsReceived++;
if (doNotEvict)
{
_nonEvictableTransactions.TryAdd(transaction.Hash, true);
if (_logger.IsDebug)
{
_logger.Debug($"Added a transaction: {transaction.Hash} that will not be evicted.");
}
}
// beware we are discarding here the old signature scheme without ChainId
if (transaction.Signature.GetChainId == null)
{
Metrics.PendingTransactionsDiscarded++;
return(AddTxResult.OldScheme);
}
if (transaction.Signature.GetChainId != _specProvider.ChainId)
{
Metrics.PendingTransactionsDiscarded++;
return(AddTxResult.InvalidChainId);
}
if (!_pendingTransactions.TryAdd(transaction.Hash, transaction))
{
Metrics.PendingTransactionsKnown++;
return(AddTxResult.AlreadyKnown);
}
if (_txStorage.Get(transaction.Hash) != null)
{
Metrics.PendingTransactionsKnown++;
return(AddTxResult.AlreadyKnown);
}
transaction.SenderAddress = _ecdsa.RecoverAddress(transaction, blockNumber);
// check nonce
if (transaction.DeliveredBy == null)
{
_ownTransactions.TryAdd(transaction.Hash, transaction);
_ownTimer.Enabled = true;
if (_logger.IsInfo)
{
_logger.Info($"Broadcasting own transaction {transaction.Hash} to {_peers.Count} peers");
}
}
NotifySelectedPeers(transaction);
FilterAndStoreTransaction(transaction, blockNumber);
NewPending?.Invoke(this, new TxEventArgs(transaction));
return(AddTxResult.Added);
}
public void RecoverData(Block block)
{
if (block.Transactions.Length == 0 || block.Transactions[0].SenderAddress != null)
{
return;
}
for (int i = 0; i < block.Transactions.Length; i++)
{
_txPool.TryGetSender(block.Transactions[i].Hash, out Address sender);
block.Transactions[i].SenderAddress = sender ?? _ecdsa.RecoverAddress(block.Transactions[i], block.Number);
}
}
private void RecoverReceiptData(IReleaseSpec releaseSpec, TxReceipt receipt, Block block, Transaction transaction, int transactionIndex, long gasUsedBefore)
{
receipt.BlockHash = block.Hash;
receipt.BlockNumber = block.Number;
receipt.TxHash = transaction.Hash;
receipt.Index = transactionIndex;
receipt.Sender = transaction.SenderAddress ?? _ecdsa.RecoverAddress(transaction, !releaseSpec.ValidateChainId);
receipt.Recipient = transaction.IsContractCreation ? null : transaction.To;
// how would it be in CREATE2?
receipt.ContractAddress = transaction.IsContractCreation ? ContractAddress.From(receipt.Sender, transaction.Nonce) : null;
receipt.GasUsed = receipt.GasUsedTotal - gasUsedBefore;
if (receipt.StatusCode != StatusCode.Success)
{
receipt.StatusCode = receipt.Logs.Length == 0 ? StatusCode.Failure : StatusCode.Success;
}
}
public void RecoverData(Block block)
{
if (block.Transactions.Length == 0 || block.Transactions[0].SenderAddress != null)
{
return;
}
for (int i = 0; i < block.Transactions.Length; i++)
{
_txPool.TryGetSender(block.Transactions[i].Hash, out Address sender);
block.Transactions[i].SenderAddress = sender ?? _ecdsa.RecoverAddress(block.Transactions[i], block.Number);
if (_logger.IsTrace)
{
_logger.Trace($"Recovered {block.Transactions[i].SenderAddress} sender for {block.Transactions[i].Hash} (tx pool cached value: {sender})");
}
}
}
public bool validate_seal(long blockNumber, Address signedAddress, Address recoveredAddress)
{
signedAddress ??= _address;
recoveredAddress ??= _address;
var block = Build.A.BlockHeader
.WithAura(10, Array.Empty <byte>())
.WithBeneficiary(_address)
.WithNumber(blockNumber)
.TestObject;
var hash = block.CalculateHash(RlpBehaviors.ForSealing);
block.AuRaSignature = _wallet.Sign(hash, signedAddress).BytesWithRecovery;
_ethereumEcdsa.RecoverAddress(Arg.Any <Signature>(), hash).Returns(recoveredAddress);
return(_sealValidator.ValidateSeal(block, false));
}
public AcceptTxResult Accept(Transaction tx, TxHandlingOptions handlingOptions)
{
/* We have encountered multiple transactions that do not resolve sender address properly.
* We need to investigate what these txs are and why the sender address is resolved to null.
* Then we need to decide whether we really want to broadcast them.
*/
if (tx.SenderAddress is null)
{
tx.SenderAddress = _ecdsa.RecoverAddress(tx);
if (tx.SenderAddress is null)
{
if (_logger.IsTrace)
{
_logger.Trace($"Skipped adding transaction {tx.ToString(" ")}, no sender.");
}
return(AcceptTxResult.FailedToResolveSender);
}
}
return(AcceptTxResult.Accepted);
}
public void RecoverTxSender(Transaction tx, long?blockNumber)
{
tx.SenderAddress = _ecdsa.RecoverAddress(tx, blockNumber ?? _blockTree.BestKnownNumber);
}
public void RecoverTxSender(Transaction tx)
{
tx.SenderAddress = _ecdsa.RecoverAddress(tx);
}
public void RecoverTxSender(Transaction tx, long blockNumber)
{
tx.SenderAddress = _ecdsa.RecoverAddress(tx, blockNumber);
}
public Address EcRecover(byte[] message, Signature signature)
{
throw new NotImplementedException();
return(_ecdsa.RecoverAddress(signature, Keccak.Compute(message)));
}
