/// <summary> /// Processes orphan transactions. /// Executed when receive a new transaction through MempoolBehavior. /// </summary> /// <param name="behavior">Memory pool behavior that received new transaction.</param> /// <param name="tx">The new transaction received.</param> public async Task ProcessesOrphansAsync(MempoolBehavior behavior, Transaction tx) { var workQueue = new Queue <OutPoint>(); var eraseQueue = new List <uint256>(); uint256 trxHash = tx.GetHash(); for (int index = 0; index < tx.Outputs.Count; index++) { workQueue.Enqueue(new OutPoint(trxHash, index)); } // Recursively process any orphan transactions that depended on this one var setMisbehaving = new List <ulong>(); while (workQueue.Any()) { List <OrphanTx> itByPrev = null; lock (this.lockObject) { List <OrphanTx> prevOrphans = this.mapOrphanTransactionsByPrev.TryGet(workQueue.Dequeue()); if (prevOrphans != null) { // Create a copy of the list so we can manage it outside of the lock. itByPrev = prevOrphans.ToList(); } } if (itByPrev == null) { continue; } foreach (OrphanTx mi in itByPrev) { Transaction orphanTx = mi.Tx; uint256 orphanHash = orphanTx.GetHash(); ulong fromPeer = mi.NodeId; 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) var stateDummy = new MempoolValidationState(true); if (await this.Validator.AcceptToMemoryPool(stateDummy, orphanTx)) { this.logger.LogInformation("accepted orphan tx {0}", orphanHash); behavior.RelayTransaction(orphanTx.GetHash()); this.signals.SignalTransaction(orphanTx); for (int index = 0; index < orphanTx.Outputs.Count; index++) { workQueue.Enqueue(new OutPoint(orphanHash, index)); } eraseQueue.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); this.logger.LogInformation("invalid orphan tx {0}", orphanHash); } // Has inputs but not accepted to mempool // Probably non-standard or insufficient fee/priority this.logger.LogInformation("removed orphan tx {0}", orphanHash); eraseQueue.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. this.AddToRecentRejects(orphanHash); } } // TODO: implement sanity checks. //this.memPool.Check(new MempoolCoinView(this.coinView, this.memPool, this.MempoolLock, this.Validator)); } } if (eraseQueue.Count > 0) { lock (this.lockObject) { foreach (uint256 hash in eraseQueue) { this.EraseOrphanTxLock(hash); } } } }
/// <summary> /// Processes orphan transactions. /// Executed when receive a new transaction through MempoolBehavior. /// </summary> /// <param name="behavior">Memory pool behavior that received new transaction.</param> /// <param name="tx">The new transaction received.</param> public async Task ProcessesOrphans(MempoolBehavior behavior, Transaction tx) { Queue <OutPoint> vWorkQueue = new Queue <OutPoint>(); List <uint256> vEraseQueue = new List <uint256>(); uint256 trxHash = tx.GetHash(); for (int 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 List <OrphanTx> itByPrev = await this.MempoolLock.ReadAsync(() => this.mapOrphanTransactionsByPrev.TryGet(vWorkQueue.Dequeue())?.ToList()); if (itByPrev == null) { continue; } foreach (OrphanTx mi in itByPrev) { Transaction orphanTx = mi.Tx; //->second.tx; uint256 orphanHash = orphanTx.GetHash(); ulong 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)) { this.mempoolLogger.LogInformation($"accepted orphan tx {orphanHash}"); await behavior.RelayTransaction(orphanTx.GetHash()); this.signals.SignalTransaction(orphanTx); for (int 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); this.mempoolLogger.LogInformation($"invalid orphan tx {orphanHash}"); } // Has inputs but not accepted to mempool // Probably non-standard or insufficient fee/priority this.mempoolLogger.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.MempoolLock.WriteAsync(() => this.recentRejects.TryAdd(orphanHash, orphanHash)); } } this.memPool.Check(new MempoolCoinView(this.coinView, this.memPool, this.MempoolLock, this.Validator)); } } foreach (uint256 hash in vEraseQueue) { await this.EraseOrphanTx(hash); } }