SyntheticBird/cuprate-hinto-janai
1
0
Fork 0
mirror of https://github.com/hinto-janai/cuprate.git synced 2024-09-28 17:31:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

add txpool msgs

Browse source
This commit is contained in:
hinto.janai 2024-09-24 18:02:39 -04:00
parent 4dc3b2c66f
commit e8de295b57
No known key found for this signature in database
GPG key ID: D47CE05FA175A499
6 changed files with 197 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
binaries/cuprated/src/rpc/request.rs
View file

@ -12,7 +12,7 @@
//! the [`blockchain`] modules contains methods for the
//! blockchain database [`tower::Service`] API.
mod address_book;
mod blockchain;
mod blockchain_manager;
mod p2p;
mod txpool;

120
binaries/cuprated/src/rpc/request/address_book.rs Normal file
View file

@ -0,0 +1,120 @@
//! Functions for TODO: doc enum message.
use std::{
collections::{HashMap, HashSet},
convert::Infallible,
sync::Arc,
};
use anyhow::{anyhow, Error};
use futures::StreamExt;
use monero_serai::block::Block;
use tower::{Service, ServiceExt};
use cuprate_helper::{
cast::{u64_to_usize, usize_to_u64},
map::split_u128_into_low_high_bits,
};
use cuprate_p2p_core::{
client::handshaker::builder::DummyAddressBook,
services::{AddressBookRequest, AddressBookResponse},
AddressBook, ClearNet, NetworkZone,
};
use cuprate_types::{
blockchain::{BlockchainReadRequest, BlockchainWriteRequest},
Chain, ExtendedBlockHeader, HardFork, OutputOnChain, VerifiedBlockInformation,
};
use crate::rpc::{CupratedRpcHandler, CupratedRpcHandlerState};
/// [`AddressBookRequest::PeerlistSize`]
pub(super) async fn peerlist_size<Z: NetworkZone>(
address_book: &mut impl AddressBook<Z>,
) -> Result<(u64, u64), Error> {
let AddressBookResponse::PeerlistSize { white, grey } = address_book
.ready()
.await
.expect("TODO")
.call(AddressBookRequest::PeerlistSize)
.await
.expect("TODO")
else {
unreachable!();
};
Ok((usize_to_u64(white), usize_to_u64(grey)))
}
/// [`AddressBookRequest::ConnectionCount`]
pub(super) async fn connection_count<Z: NetworkZone>(
address_book: &mut impl AddressBook<Z>,
) -> Result<(u64, u64), Error> {
let AddressBookResponse::ConnectionCount { incoming, outgoing } = address_book
.ready()
.await
.expect("TODO")
.call(AddressBookRequest::ConnectionCount)
.await
.expect("TODO")
else {
unreachable!();
};
Ok((usize_to_u64(incoming), usize_to_u64(outgoing)))
}
/// [`AddressBookRequest::SetBan`]
pub(super) async fn set_ban<Z: NetworkZone>(
address_book: &mut impl AddressBook<Z>,
peer: Infallible,
) -> Result<(), Error> {
let AddressBookResponse::Ok = address_book
.ready()
.await
.expect("TODO")
.call(AddressBookRequest::SetBan(peer))
.await
.expect("TODO")
else {
unreachable!();
};
Ok(())
}
/// [`AddressBookRequest::GetBan`]
pub(super) async fn get_ban<Z: NetworkZone>(
address_book: &mut impl AddressBook<Z>,
peer: Infallible,
) -> Result<(), Error> {
let AddressBookResponse::GetBan(ban) = address_book
.ready()
.await
.expect("TODO")
.call(AddressBookRequest::GetBan(peer))
.await
.expect("TODO")
else {
unreachable!();
};
Ok(())
}
/// [`AddressBookRequest::GetBans`]
pub(super) async fn get_bans<Z: NetworkZone>(
address_book: &mut impl AddressBook<Z>,
) -> Result<(), Error> {
let AddressBookResponse::GetBans(bans) = address_book
.ready()
.await
.expect("TODO")
.call(AddressBookRequest::GetBans)
.await
.expect("TODO")
else {
unreachable!();
};
Ok(todo!())
}

119
binaries/cuprated/src/rpc/request/p2p.rs
View file

@ -1,119 +0,0 @@
//! Functions for TODO: doc enum message.
use std::{
collections::{HashMap, HashSet},
convert::Infallible,
sync::Arc,
};
use anyhow::{anyhow, Error};
use futures::StreamExt;
use monero_serai::block::Block;
use tower::{Service, ServiceExt};
use cuprate_helper::{
cast::{u64_to_usize, usize_to_u64},
map::split_u128_into_low_high_bits,
};
use cuprate_p2p_core::{
client::handshaker::builder::DummyAddressBook,
services::{AddressBookRequest, AddressBookResponse},
AddressBook, ClearNet,
};
use cuprate_types::{
blockchain::{BlockchainReadRequest, BlockchainWriteRequest},
Chain, ExtendedBlockHeader, HardFork, OutputOnChain, VerifiedBlockInformation,
};
use crate::rpc::{CupratedRpcHandler, CupratedRpcHandlerState};
#[expect(clippy::needless_pass_by_ref_mut, reason = "TODO: remove after impl")]
impl CupratedRpcHandlerState {
/// [`AddressBookRequest::PeerlistSize`]
pub(super) async fn peerlist_size(&mut self) -> Result<(u64, u64), Error> {
let AddressBookResponse::<ClearNet>::PeerlistSize { white, grey } =
<DummyAddressBook as tower::ServiceExt<AddressBookRequest<ClearNet>>>::ready(
&mut DummyAddressBook,
)
.await
.expect("TODO")
.call(AddressBookRequest::PeerlistSize)
.await
.expect("TODO")
else {
unreachable!();
};
Ok((usize_to_u64(white), usize_to_u64(grey)))
}
/// [`AddressBookRequest::ConnectionCount`]
pub(super) async fn connection_count(&mut self) -> Result<(u64, u64), Error> {
let AddressBookResponse::<ClearNet>::ConnectionCount { incoming, outgoing } =
<DummyAddressBook as tower::ServiceExt<AddressBookRequest<ClearNet>>>::ready(
&mut DummyAddressBook,
)
.await
.expect("TODO")
.call(AddressBookRequest::ConnectionCount)
.await
.expect("TODO")
else {
unreachable!();
};
Ok((usize_to_u64(incoming), usize_to_u64(outgoing)))
}
/// [`AddressBookRequest::SetBan`]
pub(super) async fn set_ban(&mut self, peer: Infallible) -> Result<(), Error> {
let AddressBookResponse::<ClearNet>::Ok = <DummyAddressBook as tower::ServiceExt<
AddressBookRequest<ClearNet>,
>>::ready(&mut DummyAddressBook)
.await
.expect("TODO")
.call(AddressBookRequest::SetBan(peer))
.await
.expect("TODO") else {
unreachable!();
};
Ok(())
}
/// [`AddressBookRequest::GetBan`]
pub(super) async fn get_ban(&mut self, peer: Infallible) -> Result<(), Error> {
let AddressBookResponse::<ClearNet>::GetBan(ban) =
<DummyAddressBook as tower::ServiceExt<AddressBookRequest<ClearNet>>>::ready(
&mut DummyAddressBook,
)
.await
.expect("TODO")
.call(AddressBookRequest::GetBan(peer))
.await
.expect("TODO")
else {
unreachable!();
};
Ok(())
}
/// [`AddressBookRequest::GetBans`]
pub(super) async fn get_bans(&mut self) -> Result<(), Error> {
let AddressBookResponse::<ClearNet>::GetBans(bans) =
<DummyAddressBook as tower::ServiceExt<AddressBookRequest<ClearNet>>>::ready(
&mut DummyAddressBook,
)
.await
.expect("TODO")
.call(AddressBookRequest::GetBans)
.await
.expect("TODO")
else {
unreachable!();
};
Ok(todo!())
}
}

48
binaries/cuprated/src/rpc/request/txpool.rs
View file

@ -2,10 +2,12 @@
use std::{
collections::{HashMap, HashSet},
convert::Infallible,
sync::Arc,
};
use anyhow::{anyhow, Error};
use cuprate_database_service::DatabaseReadService;
use futures::StreamExt;
use monero_serai::block::Block;
use tower::{Service, ServiceExt};
@ -15,6 +17,10 @@ use cuprate_helper::{
cast::{u64_to_usize, usize_to_u64},
map::split_u128_into_low_high_bits,
};
use cuprate_txpool::service::{
interface::{TxpoolReadRequest, TxpoolReadResponse},
TxpoolReadHandle,
};
use cuprate_types::{
blockchain::{BlockchainReadRequest, BlockchainWriteRequest},
Chain, ExtendedBlockHeader, HardFork, OutputOnChain, VerifiedBlockInformation,
@ -22,4 +28,44 @@ use cuprate_types::{
use crate::rpc::{CupratedRpcHandler, CupratedRpcHandlerState};
impl CupratedRpcHandlerState {}
/// [`TxpoolReadRequest::Backlog`]
pub(super) async fn backlog(txpool_read: &mut TxpoolReadHandle) -> Result<Vec<Infallible>, Error> {
let TxpoolReadResponse::Backlog(backlog) = txpool_read
.ready()
.await
.expect("TODO")
.call(TxpoolReadRequest::Backlog)
.await
.expect("TODO")
else {
unreachable!();
};
Ok(backlog)
}
/// [`TxpoolReadRequest::Size`]
pub(super) async fn size(txpool_read: &mut TxpoolReadHandle) -> Result<u64, Error> {
let TxpoolReadResponse::Size(size) = txpool_read
.ready()
.await
.expect("TODO")
.call(TxpoolReadRequest::Size)
.await
.expect("TODO")
else {
unreachable!();
};
Ok(usize_to_u64(size))
}
// [`::Flush`]
#[expect(clippy::needless_pass_by_ref_mut, reason = "TODO: remove after impl")]
pub(super) async fn flush(
txpool_read: &mut TxpoolReadHandle,
tx_hashes: Vec<[u8; 32]>,
) -> Result<(), Error> {
todo!();
Ok(())
}

32
storage/txpool/src/service/interface.rs
View file

@ -12,19 +12,39 @@ use crate::types::TransactionHash;
pub enum TxpoolReadRequest {
/// A request for the blob (raw bytes) of a transaction with the given hash.
TxBlob(TransactionHash),
/// A request for the [`TransactionVerificationData`] of a transaction in the tx pool.
TxVerificationData(TransactionHash),
/// TODO
Backlog,
/// TODO
Size,
}
//---------------------------------------------------------------------------------------------------- TxpoolReadResponse
/// The transaction pool [`tower::Service`] read response type.
#[expect(clippy::large_enum_variant)]
pub enum TxpoolReadResponse {
/// A response containing the raw bytes of a transaction.
/// Response to [`TxpoolReadRequest::TxBlob`].
///
/// The inner value is the raw bytes of a transaction.
// TODO: use bytes::Bytes.
TxBlob(Vec<u8>),
/// A response of [`TransactionVerificationData`].
/// Response to [`TxpoolReadRequest::TxVerificationData`].
TxVerificationData(TransactionVerificationData),
/// Response to [`TxpoolReadRequest::Backlog`].
///
/// TODO
Backlog(Vec<std::convert::Infallible>),
/// Response to [`TxpoolReadRequest::Size`].
///
/// TODO
Size(usize),
}
//---------------------------------------------------------------------------------------------------- TxpoolWriteRequest
@ -42,6 +62,7 @@ pub enum TxpoolWriteRequest {
/// [`true`] if this tx is in the stem state.
state_stem: bool,
},
/// Remove a transaction with the given hash from the pool.
///
/// Returns [`TxpoolWriteResponse::Ok`].
@ -52,9 +73,12 @@ pub enum TxpoolWriteRequest {
/// The transaction pool [`tower::Service`] write response type.
#[derive(Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]
pub enum TxpoolWriteResponse {
/// A [`TxpoolWriteRequest::AddTransaction`] response.
/// Response to:
/// - [`TxpoolWriteRequest::RemoveTransaction`]
Ok,
/// Response to [`TxpoolWriteRequest::AddTransaction`].
///
/// If the inner value is [`Some`] the tx was not added to the pool as it double spends a tx with the given hash.
AddTransaction(Option<TransactionHash>),
Ok,
}

1
storage/txpool/src/service/read.rs
View file

@ -58,6 +58,7 @@ fn map_request(
match request {
TxpoolReadRequest::TxBlob(tx_hash) => tx_blob(env, &tx_hash),
TxpoolReadRequest::TxVerificationData(tx_hash) => tx_verification_data(env, &tx_hash),
TxpoolReadRequest::Backlog | TxpoolReadRequest::Size => todo!(),
}
}