// TODO: auto create ecdsa here
public TransactionBuilder <T> SignedAndResolved(IEthereumEcdsa ecdsa, PrivateKey privateKey, bool isEip155Enabled = true)
{
// make sure that you do not change anything in the tx after signing as this will lead to a different recovered address
ecdsa.Sign(privateKey, TestObjectInternal, isEip155Enabled);
TestObjectInternal.SenderAddress = privateKey.Address;
return(this);
}
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}).");
}
private Transaction[] SignTransactions(IEthereumEcdsa ecdsa, PrivateKey key, UInt256 baseNonce, params Transaction[] transactions)
{
for (var index = 0; index < transactions.Length; index++)
{
Transaction transaction = transactions[index];
ecdsa.Sign(key, transaction, true);
transaction.SenderAddress = key.Address;
transaction.Nonce = (UInt256)index + baseNonce;
transaction.Hash = transaction.CalculateHash();
}
return(transactions);
}
private void TestEncodeDecode(IEthereumEcdsa ecdsa)
{
AuthEip8Message authMessage = new AuthEip8Message();
authMessage.Nonce = new byte[AuthMessageSerializer.NonceLength]; // sic!
authMessage.Signature = ecdsa.Sign(_privateKey, Keccak.Compute("anything"));
authMessage.PublicKey = _privateKey.PublicKey;
_random.NextBytes(authMessage.Nonce);
byte[] data = _serializer.Serialize(authMessage);
AuthEip8Message after = _serializer.Deserialize(data);
Assert.AreEqual(authMessage.Signature, after.Signature);
Assert.AreEqual(authMessage.PublicKey, after.PublicKey);
Assert.True(Bytes.AreEqual(authMessage.Nonce, after.Nonce));
Assert.AreEqual(authMessage.Version, after.Version);
}
private void TestEncodeDecode(IEthereumEcdsa ecdsa)
{
AuthMessage authMessage = new AuthMessage();
authMessage.EphemeralPublicHash = new Keccak(new byte[AuthMessageSerializer.EphemeralHashLength]);
authMessage.Nonce = new byte[AuthMessageSerializer.NonceLength];
authMessage.Signature = ecdsa.Sign(_privateKey, Keccak.Compute("anything"));
_random.NextBytes(authMessage.EphemeralPublicHash.Bytes);
authMessage.PublicKey = _privateKey.PublicKey;
_random.NextBytes(authMessage.Nonce);
authMessage.IsTokenUsed = true;
byte[] bytes = _serializer.Serialize(authMessage);
AuthMessage after = _serializer.Deserialize(bytes);
Assert.AreEqual(authMessage.Signature, after.Signature);
Assert.AreEqual(authMessage.EphemeralPublicHash, after.EphemeralPublicHash);
Assert.AreEqual(authMessage.PublicKey, after.PublicKey);
Assert.True(Bytes.AreEqual(authMessage.Nonce, after.Nonce));
Assert.AreEqual(authMessage.IsTokenUsed, after.IsTokenUsed);
}
public TransactionBuilder <T> Signed(IEthereumEcdsa ecdsa, PrivateKey privateKey, bool isEip155Enabled = true)
{
ecdsa.Sign(privateKey, TestObjectInternal, isEip155Enabled);
return(this);
}
// TODO: auto create ecdsa here
public TransactionBuilder SignedAndResolved(IEthereumEcdsa ecdsa, PrivateKey privateKey, long blockNumber)
{
ecdsa.Sign(privateKey, TestObjectInternal, blockNumber);
TestObjectInternal.SenderAddress = privateKey.Address;
return(this);
}
public TransactionBuilder Signed(IEthereumEcdsa ecdsa, PrivateKey privateKey, long blockNumber)
{
ecdsa.Sign(privateKey, TestObjectInternal, blockNumber);
return(this);
}
