Ejemplo n.º 1
0
        public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
        {
            if (_bestChainHash == Hash.Empty)
            {
                return;
            }

            foreach (var transaction in eventData.Transactions)
            {
                if (_processTransactionJobs.InputCount > _transactionOptions.PoolLimit)
                {
                    Logger.LogWarning("Already too many transaction processing job enqueued.");
                    break;
                }

                var queuedTransaction = new QueuedTransaction
                {
                    TransactionId = transaction.GetHash(),
                    Transaction   = transaction,
                    EnqueueTime   = TimestampHelper.GetUtcNow()
                };
                var sendResult = await _processTransactionJobs.SendAsync(queuedTransaction);

                if (!sendResult)
                {
                    Logger.LogWarning($"Process transaction:{queuedTransaction.TransactionId} failed.");
                }
            }
        }
Ejemplo n.º 2
0
        public async Task HandleTransactionsReceivedAsync(TransactionsReceivedEvent eventData)
        {
            if (_bestChainHash == Hash.Empty)
            {
                return;
            }

            foreach (var transaction in eventData.Transactions)
            {
                if (_processTransactionJobs.InputCount > _transactionOptions.PoolLimit)
                {
                    break;
                }

                var queuedTransaction = new QueuedTransaction
                {
                    TransactionId = transaction.GetHash(),
                    Transaction   = transaction,
                    EnqueueTime   = TimestampHelper.GetUtcNow()
                };
                await _processTransactionJobs.SendAsync(queuedTransaction);
            }
        }
Ejemplo n.º 3
0
        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
                    });
                }
            }
        }
Ejemplo n.º 4
0
        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
                    });
                }
            }
        }