public async Task Insert_Transaction_Test()
{
var transaction = _kernelTestHelper.GenerateTransaction();
var hash = await _transactionManager.AddTransactionAsync(transaction);
hash.ShouldNotBeNull();
}
public async Task TestInsert()
{
await _manager.AddTransactionAsync(new Transaction
{
From = Address.FromRawBytes(Hash.Generate().ToByteArray()),
To = Address.FromRawBytes(Hash.Generate().ToByteArray())
});
}
public async Task AddTransactionsAsync(IEnumerable <Transaction> transactions)
{
foreach (var transaction in transactions)
{
await _transactionManager.AddTransactionAsync(transaction);
}
}
public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
{
foreach (var transaction in eventData.Transactions)
{
_allTransactions.Add(transaction.GetHash(), transaction);
await _transactionManager.AddTransactionAsync(transaction);
}
}
private async Task ProcessTransactionAsync(QueuedTransaction queuedTransaction)
{
if (_allTransactions.Count > _transactionOptions.PoolLimit)
{
return;
}
if (_allTransactions.ContainsKey(queuedTransaction.TransactionId))
{
return;
}
if (!queuedTransaction.Transaction.VerifyExpiration(_bestChainHeight))
{
return;
}
var validationResult =
await _transactionValidationService.ValidateTransactionAsync(queuedTransaction.Transaction);
if (!validationResult)
{
return;
}
var hasTransaction = await _blockchainService.HasTransactionAsync(queuedTransaction.TransactionId);
if (hasTransaction)
{
return;
}
await _transactionManager.AddTransactionAsync(queuedTransaction.Transaction);
var addSuccess = _allTransactions.TryAdd(queuedTransaction.TransactionId, queuedTransaction);
if (!addSuccess)
{
return;
}
var prefix = await GetPrefixByHeightAsync(queuedTransaction.Transaction.RefBlockNumber, _bestChainHash);
UpdateRefBlockStatus(queuedTransaction, prefix, _bestChainHeight);
if (queuedTransaction.RefBlockStatus == RefBlockStatus.RefBlockExpired)
{
return;
}
if (queuedTransaction.RefBlockStatus == RefBlockStatus.RefBlockValid)
{
await LocalEventBus.PublishAsync(new TransactionAcceptedEvent()
{
Transaction = queuedTransaction.Transaction
});
}
}
public async Task AddBlockAsync(Block block)
{
await _blockManager.AddBlockHeaderAsync(block.Header);
foreach (var transaction in block.Body.TransactionList)
{
await _transactionManager.AddTransactionAsync(transaction);
}
await _blockManager.AddBlockBodyAsync(block.Header.GetHash(), block.Body);
}
public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
{
foreach (var transaction in eventData.Transactions)
{
if (_allTransactions.ContainsKey(transaction.GetHash()))
{
continue;
}
_allTransactions.Add(transaction.GetHash(), transaction);
await _transactionManager.AddTransactionAsync(transaction);
}
}
private async Task <QueuedTransaction> AcceptTransactionAsync(QueuedTransaction queuedTransaction)
{
if (!await VerifyTransactionAcceptableAsync(queuedTransaction))
{
return(null);
}
var validationResult =
await _transactionValidationService.ValidateTransactionWhileCollectingAsync(new ChainContext
{
BlockHash = _bestChainHash,
BlockHeight = _bestChainHeight
}, queuedTransaction.Transaction);
if (!validationResult)
{
Logger.LogDebug($"Transaction {queuedTransaction.TransactionId} validation failed.");
return(null);
}
// double check
var hasTransaction = await _blockchainService.HasTransactionAsync(queuedTransaction.TransactionId);
if (hasTransaction)
{
return(null);
}
await _transactionManager.AddTransactionAsync(queuedTransaction.Transaction);
var addSuccess = _allTransactions.TryAdd(queuedTransaction.TransactionId, queuedTransaction);
if (addSuccess)
{
await UpdateQueuedTransactionRefBlockStatusAsync(queuedTransaction);
return(queuedTransaction);
}
Logger.LogWarning($"Transaction {queuedTransaction.TransactionId} insert failed.");
return(null);
}
/// <summary>
/// Update database
/// </summary>
/// <param name="executedTxs"></param>
/// <param name="txResults"></param>
/// <param name="block"></param>
private async Task <HashSet <Address> > InsertTxs(IEnumerable <Transaction> executedTxs,
IEnumerable <TransactionResult> txResults, IBlock block)
{
var bn = block.Header.Index;
var bh = block.Header.GetHash();
var address = new HashSet <Address>();
foreach (var t in executedTxs)
{
address.Add(t.From);
await _transactionManager.AddTransactionAsync(t);
}
txResults.AsParallel().ForEach(async r =>
{
r.BlockNumber = bn;
r.BlockHash = bh;
await _transactionResultManager.AddTransactionResultAsync(r);
});
return(address);
}
// Change transaction status and add transaction into TransactionManager.
private void UpdateExecutedTransactions(IEnumerable <Hash> txIds, ulong blockNumber)
{
var receipts = new List <TransactionReceipt>();
foreach (var txId in txIds)
{
if (_allTxns.TryGetValue(txId, out var tr))
{
tr.Status = TransactionReceipt.Types.TransactionStatus.TransactionExecuted;
tr.ExecutedBlockNumber = blockNumber;
_transactionManager.AddTransactionAsync(tr.Transaction);
receipts.Add(tr);
}
else
{
//TODO: Handle this, but it should never happen
}
}
_receiptManager.AddOrUpdateReceiptsAsync(receipts);
}
private async Task ProcessTransactionAsync(QueuedTransaction queuedTransaction)
{
try
{
if (_allTransactions.Count > _transactionOptions.PoolLimit)
{
return;
}
if (_allTransactions.ContainsKey(queuedTransaction.TransactionId))
{
return;
}
if (!queuedTransaction.Transaction.VerifyExpiration(_bestChainHeight))
{
Logger.LogWarning($"Transaction {queuedTransaction.TransactionId} already expired.");
return;
}
var validationResult =
await _transactionValidationService.ValidateTransactionWhileCollectingAsync(queuedTransaction
.Transaction);
if (!validationResult)
{
Logger.LogWarning($"Transaction {queuedTransaction.TransactionId} validation failed.");
return;
}
var hasTransaction = await _blockchainService.HasTransactionAsync(queuedTransaction.TransactionId);
if (hasTransaction)
{
return;
}
await _transactionManager.AddTransactionAsync(queuedTransaction.Transaction);
var addSuccess = _allTransactions.TryAdd(queuedTransaction.TransactionId, queuedTransaction);
if (!addSuccess)
{
Logger.LogWarning($"Transaction {queuedTransaction.TransactionId} insert failed.");
return;
}
var prefix = await GetPrefixByHeightAsync(queuedTransaction.Transaction.RefBlockNumber, _bestChainHash);
UpdateRefBlockStatus(queuedTransaction, prefix, _bestChainHeight);
if (queuedTransaction.RefBlockStatus == RefBlockStatus.RefBlockExpired)
{
return;
}
if (queuedTransaction.RefBlockStatus == RefBlockStatus.RefBlockValid)
{
await LocalEventBus.PublishAsync(new TransactionAcceptedEvent()
{
Transaction = queuedTransaction.Transaction
});
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Process transaction failed.");
}
}
public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
{
foreach (var transaction in eventData.Transactions)
{
if (!transaction.VerifySignature())
{
continue;
}
var receipt = new TransactionReceipt(transaction);
if (_allTransactions.ContainsKey(receipt.TransactionId))
{
Logger.LogWarning($"Transaction already exists in TxStore");
continue;
}
if (_allTransactions.Count > _transactionOptions.PoolLimit)
{
Logger.LogWarning($"TxStore is full, ignore tx {receipt.TransactionId}");
break;
}
if (transaction.CalculateSize() > TransactionPoolConsts.TransactionSizeLimit)
{
Logger.LogWarning($"Transaction {receipt.TransactionId} oversize {transaction.CalculateSize()}");
continue;
}
var txn = await _transactionManager.GetTransaction(receipt.TransactionId);
if (txn != null)
{
Logger.LogWarning($"Transaction already exists in TxStore");
continue;
}
var success = _allTransactions.TryAdd(receipt.TransactionId, receipt);
if (!success)
{
continue;
}
await _transactionManager.AddTransactionAsync(transaction);
if (_bestChainHash == Hash.Empty)
{
continue;
}
var prefix = await GetPrefixByHeightAsync(receipt.Transaction.RefBlockNumber, _bestChainHash);
CheckPrefixForOne(receipt, prefix, _bestChainHeight);
AddToRespectiveCurrentCollection(receipt);
if (receipt.RefBlockStatus == RefBlockStatus.RefBlockValid)
{
await LocalEventBus.PublishAsync(new TransactionAcceptedEvent()
{
Transaction = transaction
});
}
}
}
public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
{
var executableTransactions = new List <Transaction>();
foreach (var transaction in eventData.Transactions)
{
var receipt = new TransactionReceipt
{
TransactionId = transaction.GetHash(),
Transaction = transaction
};
if (_allTransactions.ContainsKey(receipt.TransactionId))
{
//Logger.LogWarning($"Transaction already exists in TxStore");
continue;
}
if (_allTransactions.Count > _transactionOptions.PoolLimit)
{
//Logger.LogWarning($"TxStore is full, ignore tx {receipt.TransactionId}");
break;
}
// Skip this transaction if it is already in local database.
var txn = await _transactionManager.GetTransactionAsync(receipt.TransactionId);
if (txn != null)
{
continue;
}
var validationResult = await _transactionValidationService.ValidateTransactionAsync(transaction);
if (!validationResult)
{
continue;
}
var additionResult = _allTransactions.TryAdd(receipt.TransactionId, receipt);
if (!additionResult)
{
continue;
}
await _transactionManager.AddTransactionAsync(transaction);
executableTransactions.Add(transaction);
if (_bestChainHash == Hash.Empty)
{
continue;
}
var prefix = await GetPrefixByHeightAsync(receipt.Transaction.RefBlockNumber, _bestChainHash);
CheckPrefixForOne(receipt, prefix, _bestChainHeight);
AddToRespectiveCurrentCollection(receipt);
if (receipt.RefBlockStatus == RefBlockStatus.RefBlockValid)
{
await LocalEventBus.PublishAsync(new TransactionAcceptedEvent()
{
Transaction = transaction
});
}
}
}