Reject duplicate UTXO spends and nullifier reveals within the same mempool transaction

[teor2345]

Motivation

Mempools typically require a consistent set of transactions, which could all be mined into a single block.

In order to support this restriction, Zebra should reject transactions that:

• spend the same output more than once
• reveal the same nullifier more than once

Specifications

This consensus rule applies to both block and mempool transactions, so we might want to implement it in transaction::Verifier.

Design

zebra-state already checks for double-spends within the same block transaction.
We can move this check to transaction::Verifier.

zebra/zebra-state/src/service/check/utxo.rs

Lines 76 to 85 in b714b2b

	// We don't delete the UTXOs until the block is committed,
	// so we need to check for duplicate spends within the same block.
	//
	// See `transparent_spend_chain_order` for the relevant consensus rule.
	if block_spends.insert(*spend, utxo).is_some() {
	return Err(DuplicateTransparentSpend {
	outpoint: *spend,
	location: "the same block",
	});
	}

The mempool already checks for double-spends between transactions in check_spend_conflicts:

zebra/zebrad/src/components/mempool/storage.rs

Lines 159 to 168 in 17f217b

	/// Checks if the `tx` transaction has spend conflicts with another transaction in the mempool.
	///
	/// Two transactions have a spend conflict if they spent the same UTXO or if they reveal the
	/// same nullifier.
	fn check_spend_conflicts(&self, tx: &UnminedTx) -> bool {
	self.has_spend_conflicts(tx, Transaction::spent_outpoints)
	|| self.has_spend_conflicts(tx, Transaction::sprout_nullifiers)
	|| self.has_spend_conflicts(tx, Transaction::sapling_nullifiers)
	|| self.has_spend_conflicts(tx, Transaction::orchard_nullifiers)
	}

[mpguerra]

Hey team! Please add your planning poker estimate with ZenHub @conradoplg @dconnolly @jvff @oxarbitrage @teor2345 @upbqdn