public async Task ProcessesOrphans(MempoolBehavior behavior, Transaction tx) { Queue <OutPoint> vWorkQueue = new Queue <OutPoint>(); List <uint256> vEraseQueue = new List <uint256>(); var trxHash = tx.GetHash(); for (var index = 0; index < tx.Outputs.Count; index++) { vWorkQueue.Enqueue(new OutPoint(trxHash, index)); } // Recursively process any orphan transactions that depended on this one List <ulong> setMisbehaving = new List <ulong>(); while (vWorkQueue.Any()) { // mapOrphanTransactionsByPrev.TryGet() does a .ToList() to take a new collection // of orphans as this collection may be modifed later by anotehr thread var itByPrev = await this.MempoolScheduler.ReadAsync(() => this.mapOrphanTransactionsByPrev.TryGet(vWorkQueue.Dequeue())?.ToList()); if (itByPrev == null) { continue; } foreach (var mi in itByPrev) { var orphanTx = mi.Tx; //->second.tx; var orphanHash = orphanTx.GetHash(); var fromPeer = mi.NodeId; // (*mi)->second.fromPeer; if (setMisbehaving.Contains(fromPeer)) { continue; } // Use a dummy CValidationState so someone can't setup nodes to counter-DoS based on orphan // resolution (that is, feeding people an invalid transaction based on LegitTxX in order to get // anyone relaying LegitTxX banned) MempoolValidationState stateDummy = new MempoolValidationState(true); if (await this.Validator.AcceptToMemoryPool(stateDummy, orphanTx)) { Logging.Logs.Mempool.LogInformation($"accepted orphan tx {orphanHash}"); await behavior.RelayTransaction(orphanTx.GetHash()); this.signals.Transactions.Broadcast(orphanTx); for (var index = 0; index < orphanTx.Outputs.Count; index++) { vWorkQueue.Enqueue(new OutPoint(orphanHash, index)); } vEraseQueue.Add(orphanHash); } else if (!stateDummy.MissingInputs) { int nDos = 0; if (stateDummy.IsInvalid && nDos > 0) { // Punish peer that gave us an invalid orphan tx //Misbehaving(fromPeer, nDos); setMisbehaving.Add(fromPeer); Logging.Logs.Mempool.LogInformation($"invalid orphan tx {orphanHash}"); } // Has inputs but not accepted to mempool // Probably non-standard or insufficient fee/priority Logging.Logs.Mempool.LogInformation($"removed orphan tx {orphanHash}"); vEraseQueue.Add(orphanHash); if (!orphanTx.HasWitness && !stateDummy.CorruptionPossible) { // Do not use rejection cache for witness transactions or // witness-stripped transactions, as they can have been malleated. // See https://github.com/bitcoin/bitcoin/issues/8279 for details. await this.MempoolScheduler.WriteAsync(() => this.recentRejects.TryAdd(orphanHash, orphanHash)); } } this.memPool.Check(new MempoolCoinView(this.coinView, this.memPool, this.MempoolScheduler, this.Validator)); } } foreach (var hash in vEraseQueue) { await this.EraseOrphanTx(hash); } }
private async Task AcceptToMemoryPoolWorker(MempoolValidationState state, Transaction tx, List <uint256> vHashTxnToUncache) { var context = new MempoolValidationContext(tx, state); this.PreMempoolChecks(context); // create the MemPoolCoinView and load relevant utxoset context.View = new MempoolCoinView(this.coinView, this.memPool, this.mempoolScheduler); await context.View.LoadView(context.Transaction).ConfigureAwait(false); // adding to the mem pool can only be done sequentially // use the sequential scheduler for that. await this.mempoolScheduler.WriteAsync(() => { // is it already in the memory pool? if (this.memPool.Exists(context.TransactionHash)) { state.Invalid(MempoolErrors.InPool).Throw(); } // Check for conflicts with in-memory transactions this.CheckConflicts(context); this.CheckMempoolCoinView(context); this.CreateMempoolEntry(context, state.AcceptTime); this.CheckSigOps(context); this.CheckFee(context); this.CheckRateLimit(context, state.LimitFree); this.CheckAncestors(context); this.CheckReplacment(context); this.CheckAllInputs(context); // Remove conflicting transactions from the mempool foreach (var it in context.AllConflicting) { Logging.Logs.Mempool.LogInformation( $"replacing tx {it.TransactionHash} with {context.TransactionHash} for {context.ModifiedFees - context.ConflictingFees} BTC additional fees, {context.EntrySize - context.ConflictingSize} delta bytes"); } this.memPool.RemoveStaged(context.AllConflicting, false); // This transaction should only count for fee estimation if // the node is not behind and it is not dependent on any other // transactions in the mempool bool validForFeeEstimation = IsCurrentForFeeEstimation() && this.memPool.HasNoInputsOf(tx); // Store transaction in memory this.memPool.AddUnchecked(context.TransactionHash, context.Entry, context.SetAncestors, validForFeeEstimation); // trim mempool and check if tx was trimmed if (!state.OverrideMempoolLimit) { LimitMempoolSize(this.nodeArgs.Mempool.MaxMempool * 1000000, this.nodeArgs.Mempool.MempoolExpiry * 60 * 60); if (!this.memPool.Exists(context.TransactionHash)) { state.Fail(MempoolErrors.Full).Throw(); } } // do this here inside the exclusive scheduler for better accuracy // and to avoid springing more concurrent tasks later state.MempoolSize = this.memPool.Size; state.MempoolDynamicSize = this.memPool.DynamicMemoryUsage(); this.PerformanceCounter.SetMempoolSize(state.MempoolSize); this.PerformanceCounter.SetMempoolDynamicSize(state.MempoolDynamicSize); this.PerformanceCounter.AddHitCount(1); }); // GetMainSignals().SyncTransaction(tx, NULL, CMainSignals::SYNC_TRANSACTION_NOT_IN_BLOCK); }
public Task <bool> AcceptToMemoryPool(MempoolValidationState state, Transaction tx) { state.AcceptTime = dateTimeProvider.GetTime(); return(AcceptToMemoryPoolWithTime(state, tx)); }
public MempoolErrorException(MempoolValidationState state) : base(state.ErrorMessage) { ValidationState = state; }