zecfoundation
/
zebra
mirror of https://github.com/ZcashFoundation/zebra.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

feat(rpc): add verbose support to getrawmempool (#9249) 

* feat(rpc): add verbose support to getrawmempool

* make 'if verbose' clearer

* cargo fmt

* fix unused warnings

* Update zebra-rpc/src/methods/types/get_raw_mempool.rs

Co-authored-by: Alfredo Garcia <oxarbitrage@gmail.com>

---------

Co-authored-by: Alfredo Garcia <oxarbitrage@gmail.com>
This commit is contained in:
Conrado Gouvea 2025-02-15 09:45:33 -03:00 committed by GitHub
parent b2fb1a7d56
commit 4613dcd259
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 274 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
zebra-chain/src/transaction/arbitrary.rs
View File

@ -14,7 +14,7 @@ use crate::{
parameters::{Network, NetworkUpgrade},
primitives::{Bctv14Proof, Groth16Proof, Halo2Proof, ZkSnarkProof},
sapling::{self, AnchorVariant, PerSpendAnchor, SharedAnchor},
serialization::ZcashDeserializeInto,
serialization::{self, ZcashDeserializeInto},
sprout, transparent,
value_balance::{ValueBalance, ValueBalanceError},
LedgerState,
@ -814,6 +814,8 @@ impl Arbitrary for VerifiedUnminedTx {
)
}),
any::<f32>(),
serialization::arbitrary::datetime_u32(),
any::<block::Height>(),
)
.prop_map(
|(
@ -822,6 +824,8 @@ impl Arbitrary for VerifiedUnminedTx {
legacy_sigop_count,
(conventional_actions, mut unpaid_actions),
fee_weight_ratio,
time,
height,
)| {
if unpaid_actions > conventional_actions {
unpaid_actions = conventional_actions;
@ -837,6 +841,8 @@ impl Arbitrary for VerifiedUnminedTx {
conventional_actions,
unpaid_actions,
fee_weight_ratio,
time: Some(time),
height: Some(height),
}
},
)

11
zebra-chain/src/transaction/unmined.rs
View File

@ -19,6 +19,7 @@ use std::{fmt, sync::Arc};
use crate::{
amount::{Amount, NonNegative},
block::Height,
serialization::ZcashSerialize,
transaction::{
AuthDigest, Hash,
@ -358,6 +359,14 @@ pub struct VerifiedUnminedTx {
///
/// [ZIP-317]: https://zips.z.cash/zip-0317#block-production
pub fee_weight_ratio: f32,
/// The time the transaction was added to the mempool, or None if it has not
/// reached the mempool yet.
pub time: Option<chrono::DateTime<chrono::Utc>>,
/// The tip height when the transaction was added to the mempool, or None if
/// it has not reached the mempool yet.
pub height: Option<Height>,
}
impl fmt::Debug for VerifiedUnminedTx {
@ -399,6 +408,8 @@ impl VerifiedUnminedTx {
fee_weight_ratio,
conventional_actions,
unpaid_actions,
time: None,
height: None,
})
}

76
zebra-rpc/src/methods.rs
View File

@ -6,6 +6,8 @@
//! Some parts of the `zcashd` RPC documentation are outdated.
//! So this implementation follows the `zcashd` server and `lightwalletd` client implementations.
#[cfg(feature = "getblocktemplate-rpcs")]
use std::collections::HashMap;
use std::{collections::HashSet, fmt::Debug, sync::Arc};
use chrono::Utc;
@ -56,6 +58,10 @@ pub mod trees;
pub mod types;
use types::GetRawMempool;
#[cfg(feature = "getblocktemplate-rpcs")]
use types::MempoolObject;
#[cfg(feature = "getblocktemplate-rpcs")]
pub mod get_block_template_rpcs;
@ -215,11 +221,15 @@ pub trait Rpc {
/// Returns all transaction ids in the memory pool, as a JSON array.
///
/// # Parameters
///
/// - `verbose`: (boolean, optional, default=false) true for a json object, false for array of transaction ids.
///
/// zcashd reference: [`getrawmempool`](https://zcash.github.io/rpc/getrawmempool.html)
/// method: post
/// tags: blockchain
#[method(name = "getrawmempool")]
async fn get_raw_mempool(&self) -> Result<Vec<String>>;
async fn get_raw_mempool(&self, verbose: Option<bool>) -> Result<GetRawMempool>;
/// Returns information about the given block's Sapling & Orchard tree state.
///
@ -1063,7 +1073,10 @@ where
.ok_or_misc_error("No blocks in state")
}
async fn get_raw_mempool(&self) -> Result<Vec<String>> {
async fn get_raw_mempool(&self, verbose: Option<bool>) -> Result<GetRawMempool> {
#[allow(unused)]
let verbose = verbose.unwrap_or(false);
#[cfg(feature = "getblocktemplate-rpcs")]
use zebra_chain::block::MAX_BLOCK_BYTES;
@ -1074,7 +1087,7 @@ where
let mut mempool = self.mempool.clone();
#[cfg(feature = "getblocktemplate-rpcs")]
let request = if should_use_zcashd_order {
let request = if should_use_zcashd_order || verbose {
mempool::Request::FullTransactions
} else {
mempool::Request::TransactionIds
@ -1094,27 +1107,46 @@ where
#[cfg(feature = "getblocktemplate-rpcs")]
mempool::Response::FullTransactions {
mut transactions,
transaction_dependencies: _,
transaction_dependencies,
last_seen_tip_hash: _,
} => {
// Sort transactions in descending order by fee/size, using hash in serialized byte order as a tie-breaker
transactions.sort_by_cached_key(|tx| {
// zcashd uses modified fee here but Zebra doesn't currently
// support prioritizing transactions
std::cmp::Reverse((
i64::from(tx.miner_fee) as u128 * MAX_BLOCK_BYTES as u128
/ tx.transaction.size as u128,
// transaction hashes are compared in their serialized byte-order.
tx.transaction.id.mined_id(),
))
});
if verbose {
let map = transactions
.iter()
.map(|unmined_tx| {
(
unmined_tx.transaction.id.mined_id().encode_hex(),
MempoolObject::from_verified_unmined_tx(
unmined_tx,
&transactions,
&transaction_dependencies,
),
)
})
.collect::<HashMap<_, _>>();
Ok(GetRawMempool::Verbose(map))
} else {
// Sort transactions in descending order by fee/size, using
// hash in serialized byte order as a tie-breaker. Note that
// this is only done in not verbose because in verbose mode
// a dictionary is returned, where order does not matter.
transactions.sort_by_cached_key(|tx| {
// zcashd uses modified fee here but Zebra doesn't currently
// support prioritizing transactions
std::cmp::Reverse((
i64::from(tx.miner_fee) as u128 * MAX_BLOCK_BYTES as u128
/ tx.transaction.size as u128,
// transaction hashes are compared in their serialized byte-order.
tx.transaction.id.mined_id(),
))
});
let tx_ids: Vec<String> = transactions
.iter()
.map(|unmined_tx| unmined_tx.transaction.id.mined_id().encode_hex())
.collect();
let tx_ids: Vec<String> = transactions
.iter()
.map(|unmined_tx| unmined_tx.transaction.id.mined_id().encode_hex())
.collect();
Ok(tx_ids)
Ok(GetRawMempool::TxIds(tx_ids))
}
}
mempool::Response::TransactionIds(unmined_transaction_ids) => {
@ -1126,7 +1158,7 @@ where
// Sort returned transaction IDs in numeric/string order.
tx_ids.sort();
Ok(tx_ids)
Ok(GetRawMempool::TxIds(tx_ids))
}
_ => unreachable!("unmatched response to a transactionids request"),

38
zebra-rpc/src/methods/tests/prop.rs
View File

@ -1,5 +1,7 @@
//! Randomised property tests for RPC methods.
#[cfg(feature = "getblocktemplate-rpcs")]
use std::collections::HashMap;
use std::{collections::HashSet, fmt::Debug, sync::Arc};
use futures::{join, FutureExt, TryFutureExt};
@ -27,7 +29,12 @@ use zebra_state::{BoxError, GetBlockTemplateChainInfo};
use zebra_test::mock_service::MockService;
use crate::methods::{self, types::Balance};
#[cfg(feature = "getblocktemplate-rpcs")]
use crate::methods::types::MempoolObject;
use crate::methods::{
self,
types::{Balance, GetRawMempool},
};
use super::super::{
AddressBalance, AddressStrings, NetworkUpgradeStatus, RpcImpl, RpcServer, SentTransactionHash,
@ -228,7 +235,8 @@ proptest! {
/// returns those IDs as hexadecimal strings.
#[test]
fn mempool_transactions_are_sent_to_caller(transactions in any::<Vec<VerifiedUnminedTx>>(),
network in any::<Network>()) {
network in any::<Network>(),
verbose in any::<Option<bool>>()) {
let (runtime, _init_guard) = zebra_test::init_async();
let _guard = runtime.enter();
let (mut mempool, mut state, rpc, mempool_tx_queue) = mock_services(network, NoChainTip);
@ -254,7 +262,7 @@ proptest! {
.expect_request(mempool::Request::TransactionIds)
.map_ok(|r|r.respond(mempool::Response::TransactionIds(transaction_ids)));
(expected_response, mempool_query)
(GetRawMempool::TxIds(expected_response), mempool_query)
};
// Note: this depends on `SHOULD_USE_ZCASHD_ORDER` being true.
@ -278,18 +286,38 @@ proptest! {
.map(|tx| tx.transaction.id.mined_id().encode_hex::<String>())
.collect::<Vec<_>>();
let transaction_dependencies = Default::default();
let expected_response = if verbose.unwrap_or(false) {
let map = transactions
.iter()
.map(|unmined_tx| {
(
unmined_tx.transaction.id.mined_id().encode_hex(),
MempoolObject::from_verified_unmined_tx(
unmined_tx,
&transactions,
&transaction_dependencies,
),
)
})
.collect::<HashMap<_, _>>();
GetRawMempool::Verbose(map)
} else {
GetRawMempool::TxIds(expected_response)
};
let mempool_query = mempool
.expect_request(mempool::Request::FullTransactions)
.map_ok(|r| r.respond(mempool::Response::FullTransactions {
transactions,
transaction_dependencies: Default::default(),
transaction_dependencies,
last_seen_tip_hash: [0; 32].into(),
}));
(expected_response, mempool_query)
};
let (rpc_rsp, _) = tokio::join!(rpc.get_raw_mempool(), mempool_query);
let (rpc_rsp, _) = tokio::join!(rpc.get_raw_mempool(verbose), mempool_query);
prop_assert_eq!(rpc_rsp?, expected_response);

8
zebra-rpc/src/methods/tests/snapshot.rs
View File

@ -399,9 +399,13 @@ async fn test_rpc_response_data_for_network(network: &Network) {
});
// make the api call
let get_raw_mempool = rpc.get_raw_mempool();
let get_raw_mempool = rpc.get_raw_mempool(None);
let (response, _) = futures::join!(get_raw_mempool, mempool_req);
let get_raw_mempool = response.expect("We should have a GetRawTransaction struct");
let GetRawMempool::TxIds(get_raw_mempool) =
response.expect("We should have a GetRawTransaction struct")
else {
panic!("should return TxIds for non verbose");
};
snapshot_rpc_getrawmempool(get_raw_mempool, &settings);

2
zebra-rpc/src/methods/tests/vectors.rs
View File

@ -1826,6 +1826,8 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
conventional_actions,
unpaid_actions: 0,
fee_weight_ratio: 1.0,
time: None,
height: None,
};
let next_fake_tip_hash =

2
zebra-rpc/src/methods/types.rs
View File

@ -1,7 +1,9 @@
//! Types used in RPC methods.
mod get_blockchain_info;
mod get_raw_mempool;
mod zec;
pub use get_blockchain_info::Balance;
pub use get_raw_mempool::{GetRawMempool, MempoolObject};
pub use zec::Zec;

118
zebra-rpc/src/methods/types/get_raw_mempool.rs Normal file
View File

@ -0,0 +1,118 @@
//! Types used in `getrawmempool` RPC method.
use std::collections::HashMap;
#[cfg(feature = "getblocktemplate-rpcs")]
use std::collections::HashSet;
#[cfg(feature = "getblocktemplate-rpcs")]
use hex::ToHex as _;
use super::Zec;
#[cfg(feature = "getblocktemplate-rpcs")]
use zebra_chain::transaction::VerifiedUnminedTx;
use zebra_chain::{amount::NonNegative, block::Height};
#[cfg(feature = "getblocktemplate-rpcs")]
use zebra_node_services::mempool::TransactionDependencies;
/// Response to a `getrawmempool` RPC request.
///
/// See the notes for the [`Rpc::get_raw_mempool` method].
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
#[serde(untagged)]
pub enum GetRawMempool {
/// The transaction IDs, as hex strings (verbose=0)
TxIds(Vec<String>),
/// A map of transaction IDs to mempool transaction details objects
/// (verbose=1)
Verbose(HashMap<String, MempoolObject>),
}
/// A mempool transaction details object as returned by `getrawmempool` in
/// verbose mode.
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
pub struct MempoolObject {
/// Transaction size in bytes.
pub(crate) size: u64,
/// Transaction fee in zatoshi.
pub(crate) fee: Zec<NonNegative>,
/// Transaction fee with fee deltas used for mining priority.
#[serde(rename = "modifiedfee")]
pub(crate) modified_fee: Zec<NonNegative>,
/// Local time transaction entered pool in seconds since 1 Jan 1970 GMT
pub(crate) time: i64,
/// Block height when transaction entered pool.
pub(crate) height: Height,
/// Number of in-mempool descendant transactions (including this one).
pub(crate) descendantcount: u64,
/// Size of in-mempool descendants (including this one).
pub(crate) descendantsize: u64,
/// Modified fees (see "modifiedfee" above) of in-mempool descendants
/// (including this one).
pub(crate) descendantfees: u64,
/// Transaction IDs of unconfirmed transactions used as inputs for this
/// transaction.
pub(crate) depends: Vec<String>,
}
impl MempoolObject {
#[cfg(feature = "getblocktemplate-rpcs")]
pub(crate) fn from_verified_unmined_tx(
unmined_tx: &VerifiedUnminedTx,
transactions: &[VerifiedUnminedTx],
transaction_dependencies: &TransactionDependencies,
) -> Self {
// Map transactions by their txids to make lookups easier
let transactions_by_id = transactions
.iter()
.map(|unmined_tx| (unmined_tx.transaction.id.mined_id(), unmined_tx))
.collect::<HashMap<_, _>>();
// Get txids of this transaction's descendants (dependents)
let empty_set = HashSet::new();
let deps = transaction_dependencies
.dependents()
.get(&unmined_tx.transaction.id.mined_id())
.unwrap_or(&empty_set);
let deps_len = deps.len();
// For each dependent: get the tx, then its size and fee; then sum them
// up
let (deps_size, deps_fees) = deps
.iter()
.filter_map(|id| transactions_by_id.get(id))
.map(|unmined_tx| (unmined_tx.transaction.size, unmined_tx.miner_fee))
.reduce(|(size1, fee1), (size2, fee2)| {
(size1 + size2, (fee1 + fee2).unwrap_or_default())
})
.unwrap_or((0, Default::default()));
// Create the MempoolObject from the information we have gathered
let mempool_object = MempoolObject {
size: unmined_tx.transaction.size as u64,
fee: unmined_tx.miner_fee.into(),
// Change this if we ever support fee deltas (prioritisetransaction call)
modified_fee: unmined_tx.miner_fee.into(),
time: unmined_tx
.time
.map(|time| time.timestamp())
.unwrap_or_default(),
height: unmined_tx.height.unwrap_or(Height(0)),
// Note that the following three count this transaction itself
descendantcount: deps_len as u64 + 1,
descendantsize: (deps_size + unmined_tx.transaction.size) as u64,
descendantfees: (deps_fees + unmined_tx.miner_fee)
.unwrap_or_default()
.into(),
// Get dependencies as a txid vector
depends: transaction_dependencies
.dependencies()
.get(&unmined_tx.transaction.id.mined_id())
.cloned()
.unwrap_or_else(HashSet::new)
.iter()
.map(|id| id.encode_hex())
.collect(),
};
mempool_object
}
}

2
zebrad/src/components/inbound/tests/fake_peer_set.rs
View File

@ -1073,7 +1073,7 @@ fn add_some_stuff_to_mempool(
// Insert the genesis block coinbase transaction into the mempool storage.
mempool_service
.storage()
.insert(genesis_transactions[0].clone(), Vec::new())
.insert(genesis_transactions[0].clone(), Vec::new(), None)
.unwrap();
genesis_transactions

3
zebrad/src/components/mempool.rs
View File

@ -595,7 +595,8 @@ impl Service<Request> for Mempool {
// the best chain changes (which is the only way to stay at the same height), and the
// mempool re-verifies all pending tx_downloads when there's a `TipAction::Reset`.
if best_tip_height == expected_tip_height {
let insert_result = storage.insert(tx.clone(), spent_mempool_outpoints);
let insert_result =
storage.insert(tx, spent_mempool_outpoints, best_tip_height);
tracing::trace!(
?insert_result,

12
zebrad/src/components/mempool/storage.rs
View File

@ -17,6 +17,7 @@ use std::{
use thiserror::Error;
use zebra_chain::{
block::Height,
transaction::{self, Hash, Transaction, UnminedTx, UnminedTxId, VerifiedUnminedTx},
transparent,
};
@ -203,6 +204,7 @@ impl Storage {
&mut self,
tx: VerifiedUnminedTx,
spent_mempool_outpoints: Vec<transparent::OutPoint>,
height: Option<Height>,
) -> Result<UnminedTxId, MempoolError> {
// # Security
//
@ -238,10 +240,12 @@ impl Storage {
// Then, we try to insert into the pool. If this fails the transaction is rejected.
let mut result = Ok(unmined_tx_id);
if let Err(rejection_error) =
self.verified
.insert(tx, spent_mempool_outpoints, &mut self.pending_outputs)
{
if let Err(rejection_error) = self.verified.insert(
tx,
spent_mempool_outpoints,
&mut self.pending_outputs,
height,
) {
tracing::debug!(
?tx_id,
?rejection_error,

20
zebrad/src/components/mempool/storage/tests/prop.rs
View File

@ -72,7 +72,7 @@ proptest! {
for (transaction_to_accept, transaction_to_reject) in input_permutations {
let id_to_accept = transaction_to_accept.transaction.id;
prop_assert_eq!(storage.insert(transaction_to_accept, Vec::new()), Ok(id_to_accept));
prop_assert_eq!(storage.insert(transaction_to_accept, Vec::new(), None), Ok(id_to_accept));
// Make unique IDs by converting the index to bytes, and writing it to each ID
let unique_ids = (0..MAX_EVICTION_MEMORY_ENTRIES as u32).map(move |index| {
@ -96,7 +96,7 @@ proptest! {
// - transaction_to_accept, or
// - a rejection from rejections
prop_assert_eq!(
storage.insert(transaction_to_reject, Vec::new()),
storage.insert(transaction_to_reject, Vec::new(), None),
Err(MempoolError::StorageEffectsTip(SameEffectsTipRejectionError::SpendConflict))
);
@ -147,13 +147,13 @@ proptest! {
if i < transactions.len() - 1 {
// The initial transactions should be successful
prop_assert_eq!(
storage.insert(transaction.clone(), Vec::new()),
storage.insert(transaction.clone(), Vec::new(), None),
Ok(tx_id)
);
} else {
// The final transaction will cause a random eviction,
// which might return an error if this transaction is chosen
let result = storage.insert(transaction.clone(), Vec::new());
let result = storage.insert(transaction.clone(), Vec::new(), None);
if result.is_ok() {
prop_assert_eq!(
@ -281,10 +281,10 @@ proptest! {
let id_to_accept = transaction_to_accept.transaction.id;
let id_to_reject = transaction_to_reject.transaction.id;
prop_assert_eq!(storage.insert(transaction_to_accept, Vec::new()), Ok(id_to_accept));
prop_assert_eq!(storage.insert(transaction_to_accept, Vec::new(), None), Ok(id_to_accept));
prop_assert_eq!(
storage.insert(transaction_to_reject, Vec::new()),
storage.insert(transaction_to_reject, Vec::new(), None),
Err(MempoolError::StorageEffectsTip(SameEffectsTipRejectionError::SpendConflict))
);
@ -332,19 +332,19 @@ proptest! {
let id_to_reject = transaction_to_reject.transaction.id;
prop_assert_eq!(
storage.insert(first_transaction_to_accept, Vec::new()),
storage.insert(first_transaction_to_accept, Vec::new(), None),
Ok(first_id_to_accept)
);
prop_assert_eq!(
storage.insert(transaction_to_reject, Vec::new()),
storage.insert(transaction_to_reject, Vec::new(), None),
Err(MempoolError::StorageEffectsTip(SameEffectsTipRejectionError::SpendConflict))
);
prop_assert!(storage.contains_rejected(&id_to_reject));
prop_assert_eq!(
storage.insert(second_transaction_to_accept, Vec::new()),
storage.insert(second_transaction_to_accept, Vec::new(), None),
Ok(second_id_to_accept)
);
@ -371,7 +371,7 @@ proptest! {
.filter_map(|transaction| {
let id = transaction.transaction.id;
storage.insert(transaction.clone(), Vec::new()).ok().map(|_| id)
storage.insert(transaction.clone(), Vec::new(), None).ok().map(|_| id)
})
.collect();

15
zebrad/src/components/mempool/storage/tests/vectors.rs
View File

@ -40,7 +40,7 @@ fn mempool_storage_crud_exact_mainnet() {
.expect("at least one unmined transaction");
// Insert unmined tx into the mempool.
let _ = storage.insert(unmined_tx.clone(), Vec::new());
let _ = storage.insert(unmined_tx.clone(), Vec::new(), None);
// Check that it is in the mempool, and not rejected.
assert!(storage.contains_transaction_exact(&unmined_tx.transaction.id.mined_id()));
@ -94,7 +94,7 @@ fn mempool_storage_basic_for_network(network: Network) -> Result<()> {
let mut maybe_inserted_transactions = Vec::new();
let mut some_rejected_transactions = Vec::new();
for unmined_transaction in unmined_transactions.clone() {
let result = storage.insert(unmined_transaction.clone(), Vec::new());
let result = storage.insert(unmined_transaction.clone(), Vec::new(), None);
match result {
Ok(_) => {
// While the transaction was inserted here, it can be rejected later.
@ -168,7 +168,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
.expect("at least one unmined transaction");
// Insert unmined tx into the mempool.
let _ = storage.insert(unmined_tx_1.clone(), Vec::new());
let _ = storage.insert(unmined_tx_1.clone(), Vec::new(), None);
// Check that it is in the mempool, and not rejected.
assert!(storage.contains_transaction_exact(&unmined_tx_1.transaction.id.mined_id()));
@ -189,7 +189,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
Some(SameEffectsChainRejectionError::Mined.into())
);
assert_eq!(
storage.insert(unmined_tx_1, Vec::new()),
storage.insert(unmined_tx_1, Vec::new(), None),
Err(SameEffectsChainRejectionError::Mined.into())
);
@ -207,7 +207,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
// Insert unmined tx into the mempool.
assert_eq!(
storage.insert(unmined_tx_2.clone(), Vec::new()),
storage.insert(unmined_tx_2.clone(), Vec::new(), None),
Ok(unmined_tx_2.transaction.id)
);
@ -230,7 +230,7 @@ fn mempool_storage_crud_same_effects_mainnet() {
Some(SameEffectsChainRejectionError::DuplicateSpend.into())
);
assert_eq!(
storage.insert(unmined_tx_2, Vec::new()),
storage.insert(unmined_tx_2, Vec::new(), None),
Err(SameEffectsChainRejectionError::DuplicateSpend.into())
);
}
@ -272,6 +272,7 @@ fn mempool_expired_basic_for_network(network: Network) -> Result<()> {
)
.expect("verification should pass"),
Vec::new(),
None,
)?;
assert_eq!(storage.transaction_count(), 1);
@ -329,7 +330,7 @@ fn mempool_removes_dependent_transactions() -> Result<()> {
}
storage
.insert(unmined_tx.clone(), fake_spent_outpoints)
.insert(unmined_tx.clone(), fake_spent_outpoints, None)
.expect("should insert transaction");
// Add up to 5 of this transaction's outputs as fake spent outpoints for the next transaction

6
zebrad/src/components/mempool/storage/verified_set.rs
View File

@ -7,6 +7,7 @@ use std::{
};
use zebra_chain::{
block::Height,
orchard, sapling, sprout,
transaction::{self, UnminedTx, VerifiedUnminedTx},
transparent,
@ -141,9 +142,10 @@ impl VerifiedSet {
/// same nullifier.
pub fn insert(
&mut self,
transaction: VerifiedUnminedTx,
mut transaction: VerifiedUnminedTx,
spent_mempool_outpoints: Vec<transparent::OutPoint>,
pending_outputs: &mut PendingOutputs,
height: Option<Height>,
) -> Result<(), SameEffectsTipRejectionError> {
if self.has_spend_conflicts(&transaction.transaction) {
return Err(SameEffectsTipRejectionError::SpendConflict);
@ -176,6 +178,8 @@ impl VerifiedSet {
self.transactions_serialized_size += transaction.transaction.size;
self.total_cost += transaction.cost();
transaction.time = Some(chrono::Utc::now());
transaction.height = height;
self.transactions.insert(tx_id, transaction);
self.update_metrics();

6
zebrad/src/components/mempool/tests/prop.rs
View File

@ -74,7 +74,7 @@ proptest! {
// Insert a dummy transaction.
mempool
.storage()
.insert(transaction.0, Vec::new())
.insert(transaction.0, Vec::new(), None)
.expect("Inserting a transaction should succeed");
// The first call to `poll_ready` shouldn't clear the storage yet.
@ -148,7 +148,7 @@ proptest! {
// Insert the dummy transaction into the mempool.
mempool
.storage()
.insert(transaction.0.clone(), Vec::new())
.insert(transaction.0.clone(), Vec::new(), None)
.expect("Inserting a transaction should succeed");
// Set the new chain tip.
@ -205,7 +205,7 @@ proptest! {
// Insert a dummy transaction.
mempool
.storage()
.insert(transaction, Vec::new())
.insert(transaction, Vec::new(), None)
.expect("Inserting a transaction should succeed");
// The first call to `poll_ready` shouldn't clear the storage yet.

8
zebrad/src/components/mempool/tests/vector.rs
View File

@ -63,7 +63,7 @@ async fn mempool_service_basic_single() -> Result<(), Report> {
let mut inserted_ids = HashSet::new();
service
.storage()
.insert(genesis_transaction.clone(), Vec::new())?;
.insert(genesis_transaction.clone(), Vec::new(), None)?;
inserted_ids.insert(genesis_transaction.transaction.id);
// Test `Request::TransactionIds`
@ -133,7 +133,7 @@ async fn mempool_service_basic_single() -> Result<(), Report> {
inserted_ids.insert(tx.transaction.id);
// Error must be ignored because a insert can trigger an eviction and
// an error is returned if the transaction being inserted in chosen.
let _ = service.storage().insert(tx.clone(), Vec::new());
let _ = service.storage().insert(tx.clone(), Vec::new(), None);
}
// Test `Request::RejectedTransactionIds`
@ -214,7 +214,7 @@ async fn mempool_queue_single() -> Result<(), Report> {
for tx in transactions.iter() {
// Error must be ignored because a insert can trigger an eviction and
// an error is returned if the transaction being inserted in chosen.
let _ = service.storage().insert(tx.clone(), Vec::new());
let _ = service.storage().insert(tx.clone(), Vec::new(), None);
}
// Test `Request::Queue` for a new transaction
@ -297,7 +297,7 @@ async fn mempool_service_disabled() -> Result<(), Report> {
// Insert the genesis block coinbase transaction into the mempool storage.
service
.storage()
.insert(genesis_transaction.clone(), Vec::new())?;
.insert(genesis_transaction.clone(), Vec::new(), None)?;
// Test if the mempool answers correctly (i.e. is enabled)
let response = service