/// <summary> /// Processing of the transaction payload message from peer. /// Adds transaction from the transaction payload to the memory pool. /// </summary> /// <param name="peer">Peer sending the message.</param> /// <param name="transactionPayload">The payload for the message.</param> private async Task ProcessTxPayloadAsync(INetworkPeer peer, TxPayload transactionPayload) { // Stop processing the transaction early if we are in blocks only mode. if (this.isBlocksOnlyMode) { this.logger.LogDebug("Transaction sent in violation of protocol from peer '{0}'.", peer.RemoteSocketEndpoint); this.logger.LogTrace("(-)[BLOCKSONLY]"); return; } Transaction trx = transactionPayload.Obj; uint256 trxHash = trx.GetHash(); // add to local filter lock (this.lockObject) { this.filterInventoryKnown.Add(trxHash); } this.logger.LogDebug("Added transaction ID '{0}' to known inventory filter.", trxHash); var state = new MempoolValidationState(true); if (!await this.orphans.AlreadyHaveAsync(trxHash) && await this.validator.AcceptToMemoryPool(state, trx)) { await this.validator.SanityCheck(); this.RelayTransaction(trxHash); this.signals.Publish(new TransactionReceived(trx)); long mmsize = state.MempoolSize; long memdyn = state.MempoolDynamicSize; this.logger.LogDebug("Transaction ID '{0}' accepted to memory pool from peer '{1}' (poolsz {2} txn, {3} kb).", trxHash, peer.RemoteSocketEndpoint, mmsize, memdyn / 1000); await this.orphans.ProcessesOrphansAsync(this, trx); } else if (state.MissingInputs) { this.orphans.ProcessesOrphansMissingInputs(peer, trx); } else { // 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. if (!trx.HasWitness && !state.CorruptionPossible) { this.orphans.AddToRecentRejects(trxHash); } // Always relay transactions received from whitelisted peers, even // if they were already in the mempool or rejected from it due // to policy, allowing the node to function as a gateway for // nodes hidden behind it. // // Never relay transactions that we would assign a non-zero DoS // score for, as we expect peers to do the same with us in that // case. if (this.isPeerWhitelistedForRelay) { if (!state.IsInvalid) { this.logger.LogDebug("Force relaying transaction ID '{0}' from whitelisted peer '{1}'.", trxHash, peer.RemoteSocketEndpoint); this.RelayTransaction(trxHash); } else { this.logger.LogDebug("Not relaying invalid transaction ID '{0}' from whitelisted peer '{1}' ({2}).", trxHash, peer.RemoteSocketEndpoint, state); } } } if (state.IsInvalid) { this.logger.LogDebug("Transaction ID '{0}' from peer '{1}' was not accepted. Invalid state of '{2}'.", trxHash, peer.RemoteSocketEndpoint, state); } }
/// <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.LogDebug("accepted orphan tx {0}", orphanHash); behavior.RelayTransaction(orphanTx.GetHash()); this.signals.Publish(new TransactionReceived(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.LogDebug("invalid orphan tx {0}", orphanHash); } // Has inputs but not accepted to mempool // Probably non-standard or insufficient fee/priority this.logger.LogDebug("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); } } } }