refactor: drop trait bounds from structs (#4251)

Author: anodar

crates/node/src/assets.rs

@@ -37,7 +37,7 @@ use std::sync::{Arc, Mutex};
 /// NB: Assets may be reordered by these operations. No guarantees are made on the order in which
 /// assets are taken or discarded from the queue.
 ///
-struct ColdQueue<T, CondVal: Default + Eq> {
+struct ColdQueue<T, CondVal> {
     cold_ready: usize,
     cold_available: usize,
     cold_queue: VecDeque<(UniqueId, T)>,
@@ -227,10 +227,7 @@ enum ColdQueueAddIfNotSatisfiedResult<T> {
     Enqueued,
 }
 
-pub struct DoubleQueue<T, CondVal: Default + Eq>
-where
-    T: Send + 'static,
-{
+pub struct DoubleQueue<T, CondVal> {
     hot_sender: flume::Sender<(UniqueId, T)>,
     hot_receiver: flume::Receiver<(UniqueId, T)>,
     cold_queue: Arc<Mutex<ColdQueue<T, CondVal>>>,
@@ -432,10 +429,7 @@ where
 ///
 /// As a passive participant of a computation, unowned assets are taken using
 /// `take_unowned`.
-pub struct DistributedAssetStorage<T>
-where
-    T: Serialize + DeserializeOwned + Send + 'static,
-{
+pub struct DistributedAssetStorage<T> {
     db: Arc<SecretDB>,
     col: DBCol,
     /// Byte prefix prepended to every key written under `col`. Empty [`Vec`] means

crates/node/src/network/conn.rs

@@ -23,7 +23,7 @@ pub struct ConnectionVersion {
 /// and the weak ptr points to nothing. So version() returns 1, meaning that
 /// when to send or receive anything, we would wait until the first connection
 /// is established.
-pub struct ConnectionWithVersion<T: Send + Sync + 'static> {
+pub struct ConnectionWithVersion<T> {
     pub connection: Weak<T>,
     version: usize,
 }
@@ -68,7 +68,7 @@ where
 
 /// Struct to track bidirectional connectivity between two nodes.
 /// A node has one NodeConnectivity for each other node in the network.
-pub struct NodeConnectivity<I: Send + Sync + 'static, O: Send + Sync + 'static> {
+pub struct NodeConnectivity<I, O> {
     outgoing_sender: tokio::sync::watch::Sender<ConnectionWithVersion<I>>,
     outgoing_receiver: tokio::sync::watch::Receiver<ConnectionWithVersion<I>>,
     incoming_sender: tokio::sync::watch::Sender<ConnectionWithVersion<O>>,
@@ -284,7 +284,7 @@ where
 }
 
 /// Convenient collection of multiple NodeConnectivity objects.
-pub struct AllNodeConnectivities<I: Send + Sync + 'static, O: Send + Sync + 'static> {
+pub struct AllNodeConnectivities<I, O> {
     connectivities: HashMap<ParticipantId, Arc<NodeConnectivity<I, O>>>,
 }
 

crates/node/src/providers/ecdsa_common.rs

@@ -37,9 +37,7 @@ impl<P> HasParticipants for PresignOutputWithParticipants<P> {
 
 /// Per-domain presignature store, keyed on disk by `domain_id` under [`crate::db::DBCol::Presignature`].
 #[derive(derive_more::Deref)]
-pub struct PresignatureStorage<P>(DistributedAssetStorage<PresignOutputWithParticipants<P>>)
-where
-    P: Serialize + DeserializeOwned + Send + 'static;
+pub struct PresignatureStorage<P>(DistributedAssetStorage<PresignOutputWithParticipants<P>>);
 
 impl<P> PresignatureStorage<P>
 where
@@ -69,10 +67,7 @@ where
 
 /// A domain's [`DomainKeyshare`] material plus a presignature store, which is runtime state the
 /// coordinator can't provide and so is built here.
-pub struct EcdsaKeyshare<P>
-where
-    P: Serialize + DeserializeOwned + Send + 'static,
-{
+pub struct EcdsaKeyshare<P> {
     pub keygen_output: KeygenOutput,
     pub presignature_store: Arc<PresignatureStorage<P>>,
     pub reconstruction_threshold: ReconstructionThreshold,

crates/node/src/requests/debug.rs

@@ -15,7 +15,7 @@ const NUM_COMPLETED_REQUESTS_TO_KEEP: usize = 100;
 
 /// A completed request, kept for surfacing on the queue's debug
 /// endpoints (`/debug/signatures`, `/debug/ckds`).
-pub(super) struct CompletedRequest<RequestType: Request, ChainRespondArgsType: ChainRespondArgs> {
+pub(super) struct CompletedRequest<RequestType, ChainRespondArgsType> {
     pub request: RequestType,
     pub progress: Arc<Mutex<ComputationProgress<ChainRespondArgsType>>>,
     pub indexed_block_height: BlockHeight,
@@ -27,7 +27,7 @@ pub(super) struct CompletedRequest<RequestType: Request, ChainRespondArgsType: C
 /// A buffer of completed requests, surfaced on the queue's debug
 /// endpoints (`/debug/signatures`, `/debug/ckds`). Keeps the most
 /// recent `NUM_COMPLETED_REQUESTS_TO_KEEP` requests.
-pub(super) struct CompletedRequests<RequestType: Request, ChainRespondArgsType: ChainRespondArgs> {
+pub(super) struct CompletedRequests<RequestType, ChainRespondArgsType> {
     /// Min-heap, so that the oldest requests are at the front to be removed.
     requests: BinaryHeap<CompletedRequest<RequestType, ChainRespondArgsType>>,
 }

crates/node/src/requests/queue.rs

@@ -79,11 +79,7 @@ impl<RequestType> RefineEligibleLeaders<RequestType> for NoRefinement {
 ///    the queue will adapt to the new state and attempt to find new leaders for the requests.
 ///  - If a request is too old so that it would have timed out on chain, it will be
 ///    discarded.
-pub struct PendingRequests<
-    RequestType: Request,
-    ChainRespondArgsType: ChainRespondArgs,
-    Refiner: RefineEligibleLeaders<RequestType> = NoRefinement,
-> {
+pub struct PendingRequests<RequestType, ChainRespondArgsType, Refiner = NoRefinement> {
     pub(super) clock: near_time::Clock,
 
     /// All participants in the network, regardless of whether they are online.
@@ -181,7 +177,7 @@ enum AggregateResponseStatus {
 }
 
 /// The state of a single request in the queue.
-pub(super) struct QueuedRequest<RequestType: Request, ChainRespondArgsType: ChainRespondArgs> {
+pub(super) struct QueuedRequest<RequestType, ChainRespondArgsType> {
     pub request: RequestType,
 
     /// Finality status of the block the request was included in.
@@ -216,15 +212,15 @@ pub(super) struct QueuedRequest<RequestType: Request, ChainRespondArgsType: Chai
 }
 
 /// Struct given to the response generation code.
-pub struct GenerationAttempt<RequestType: Request, ChainRespondArgsType: ChainRespondArgs> {
+pub struct GenerationAttempt<RequestType, ChainRespondArgsType> {
     /// The request we should attempt to generate for.
     pub request: RequestType,
     /// The progress of the computation. Writable and survives multiple attempts.
     pub computation_progress: Arc<Mutex<ComputationProgress<ChainRespondArgsType>>>,
 }
 
 /// Progress that persists across attempts.
-pub struct ComputationProgress<ChainRespondArgsType: ChainRespondArgs> {
+pub struct ComputationProgress<ChainRespondArgsType> {
     /// Number of attempts that have been made to generate the request.
     /// This is used to abort after too many attempts.
     pub attempts: u64,
@@ -442,7 +438,7 @@ impl<RequestType: Request + Clone, ChainRespondArgsType: ChainRespondArgs>
     }
 }
 
-enum RequestStatus<RequestType: Request, ChainRespondArgsType: ChainRespondArgs> {
+enum RequestStatus<RequestType, ChainRespondArgsType> {
     Drop(DropReason),
     Wait(&'static str),
     Attempt(Arc<GenerationAttempt<RequestType, ChainRespondArgsType>>),