Skip to content

Commit 00dade5

Browse files
cdxkerdensumesh
cdxker
authored and
densumesh
committed
feature: change the handle trait def to always be a non-optional
1 parent 6ab49df commit 00dade5

8 files changed

Lines changed: 142 additions & 142 deletions

File tree

‎crates/node/src/handlers/balance/mod.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -19,13 +19,13 @@ impl<N: Network, W: Wallet> Handler<N, W> for BalanceState {
1919
async fn handle(
2020
&mut self,
2121
node: &mut NodeState<N, W>,
22-
message: Option<NetworkEvent>,
22+
message: NetworkEvent,
2323
) -> Result<(), NodeError> {
2424
match message {
25-
Some(NetworkEvent::SelfRequest {
25+
NetworkEvent::SelfRequest {
2626
request: SelfRequest::CheckBalance { address },
2727
response_channel,
28-
}) => {
28+
} => {
2929
let ChainResponse::GetAccount { account } = node
3030
.chain_interface_tx
3131
.send_message_with_response(ChainMessage::GetAccount {
@@ -48,10 +48,10 @@ impl<N: Network, W: Wallet> Handler<N, W> for BalanceState {
4848
.map_err(|e| NodeError::Error(format!("Failed to send response: {e}")))?;
4949
}
5050
}
51-
Some(NetworkEvent::SelfRequest {
51+
NetworkEvent::SelfRequest {
5252
request: SelfRequest::GetChainInfo,
5353
response_channel,
54-
}) => {
54+
} => {
5555
let ChainResponse::GetChainState { state } = node
5656
.chain_interface_tx
5757
.send_message_with_response(ChainMessage::GetChainState)
@@ -74,10 +74,10 @@ impl<N: Network, W: Wallet> Handler<N, W> for BalanceState {
7474
.map_err(|e| NodeError::Error(format!("Failed to send response: {e}")))?;
7575
}
7676
}
77-
Some(NetworkEvent::SelfRequest {
77+
NetworkEvent::SelfRequest {
7878
request: SelfRequest::GetLatestBlocks { count: _ },
7979
response_channel,
80-
}) => {
80+
} => {
8181
let ChainResponse::GetChainState { state } = node
8282
.chain_interface_tx
8383
.send_message_with_response(ChainMessage::GetChainState)

‎crates/node/src/handlers/consensus/handler.rs‎

Lines changed: 93 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ impl<N: Network, W: Wallet> Handler<N, W> for ConsensusState {
2525
async fn handle(
2626
&mut self,
2727
node: &mut NodeState<N, W>,
28-
message: Option<NetworkEvent>,
28+
message: NetworkEvent,
2929
) -> Result<(), NodeError> {
3030
if self.is_leader && self.current_state == ConsensusPhase::WaitingForPropose {
3131
if let Ok(ChainResponse::GetProposedBlock { block }) = node
@@ -72,115 +72,113 @@ impl<N: Network, W: Wallet> Handler<N, W> for ConsensusState {
7272
}
7373
}
7474

75-
if let Some(message) = message {
76-
match message {
77-
NetworkEvent::SelfRequest {
78-
request: SelfRequest::TriggerConsensusRound { force_round },
79-
response_channel,
80-
} => {
81-
self.start_new_round(node)?;
82-
let round_number = self.current_round;
83-
84-
if let Some(response_channel) = response_channel {
85-
response_channel
86-
.send(SelfResponse::TriggerConsensusRoundResponse {
87-
success: true,
88-
message: if force_round {
89-
"Forced consensus round triggered".to_string()
90-
} else {
91-
"Consensus round triggered".to_string()
92-
},
93-
round_number: u64::from(round_number),
94-
})
95-
.map_err(|e| {
96-
NodeError::Error(format!("Failed to send response: {e}"))
97-
})?;
98-
}
75+
match message {
76+
NetworkEvent::SelfRequest {
77+
request: SelfRequest::TriggerConsensusRound { force_round },
78+
response_channel,
79+
} => {
80+
self.start_new_round(node)?;
81+
let round_number = self.current_round;
82+
83+
if let Some(response_channel) = response_channel {
84+
response_channel
85+
.send(SelfResponse::TriggerConsensusRoundResponse {
86+
success: true,
87+
message: if force_round {
88+
"Forced consensus round triggered".to_string()
89+
} else {
90+
"Consensus round triggered".to_string()
91+
},
92+
round_number: u64::from(round_number),
93+
})
94+
.map_err(|e| {
95+
NodeError::Error(format!("Failed to send response: {e}"))
96+
})?;
9997
}
100-
NetworkEvent::Subscribed { peer_id, topic } => {
101-
if topic == self.broadcast_topic.hash() {
102-
self.validators.insert(peer_id);
103-
104-
info!(
105-
"🔗 Peer {} subscribed to broadcast topic. Validator set size: {}",
106-
node.network_handle.peer_name(&peer_id),
107-
self.validators.len()
108-
);
109-
110-
if self.current_round == 0 {
111-
self.start_new_round(node)?;
112-
}
98+
}
99+
NetworkEvent::Subscribed { peer_id, topic } => {
100+
if topic == self.broadcast_topic.hash() {
101+
self.validators.insert(peer_id);
102+
103+
info!(
104+
"🔗 Peer {} subscribed to broadcast topic. Validator set size: {}",
105+
node.network_handle.peer_name(&peer_id),
106+
self.validators.len()
107+
);
108+
109+
if self.current_round == 0 {
110+
self.start_new_round(node)?;
113111
}
114112
}
115-
NetworkEvent::GossipsubMessage(message) => {
116-
if let Some(peer) = message.source {
117-
let broadcast = BroadcastMessage::decode(&message.data).map_err(|e| {
118-
NodeError::Error(format!("Failed to decode broadcast message: {e}"))
119-
})?;
113+
}
114+
NetworkEvent::GossipsubMessage(message) => {
115+
if let Some(peer) = message.source {
116+
let broadcast = BroadcastMessage::decode(&message.data).map_err(|e| {
117+
NodeError::Error(format!("Failed to decode broadcast message: {e}"))
118+
})?;
120119

121-
match broadcast {
122-
BroadcastMessage::Consensus(consensus_message) => {
123-
match consensus_message {
124-
ConsensusMessage::LeaderAnnouncement(announcement) => {
125-
self.handle_leader_announcement(node, &announcement)?;
126-
}
127-
ConsensusMessage::NewRound(round) => {
128-
self.handle_new_round(node, peer, round)?;
129-
}
130-
ConsensusMessage::Vote(vote) => {
131-
self.handle_vote(node, peer, &vote).await;
132-
}
120+
match broadcast {
121+
BroadcastMessage::Consensus(consensus_message) => {
122+
match consensus_message {
123+
ConsensusMessage::LeaderAnnouncement(announcement) => {
124+
self.handle_leader_announcement(node, &announcement)?;
125+
}
126+
ConsensusMessage::NewRound(round) => {
127+
self.handle_new_round(node, peer, round)?;
128+
}
129+
ConsensusMessage::Vote(vote) => {
130+
self.handle_vote(node, peer, &vote).await;
133131
}
134132
}
135-
BroadcastMessage::Block(raw_block) => {
136-
match Block::deserialize(&raw_block) {
137-
Ok(block) => {
133+
}
134+
BroadcastMessage::Block(raw_block) => {
135+
match Block::deserialize(&raw_block) {
136+
Ok(block) => {
137+
info!(
138+
"📥 Received block proposal for round {} from {} with {} txs",
139+
self.current_round,
140+
peer,
141+
block.body.transactions.len()
142+
);
143+
let Ok(ChainResponse::GetProposedBlock {
144+
block: local_block,
145+
}) = node
146+
.chain_interface_tx
147+
.send_message_with_response(
148+
ChainMessage::GetProposedBlock {
149+
previous_block: None,
150+
proposer: self.proposer.unwrap().to_bytes(),
151+
},
152+
)
153+
.await
154+
else {
155+
return Err(NodeError::Error(
156+
"Failed to get proposed block".to_string(),
157+
));
158+
};
159+
160+
if local_block == block {
161+
info!("Block is valid. Sending prevote.");
162+
self.send_vote(node, &block, VoteType::Prevote)?;
163+
} else {
164+
info!(
165+
"Block is invalid. Not voting - transaction mismatch"
166+
);
138167
info!(
139-
"📥 Received block proposal for round {} from {} with {} txs",
140-
self.current_round,
141-
peer,
142-
block.body.transactions.len()
168+
"Local txs: {:?}, Received txs: {:?}",
169+
local_block.body.transactions,
170+
block.body.transactions
143171
);
144-
let Ok(ChainResponse::GetProposedBlock {
145-
block: local_block,
146-
}) = node
147-
.chain_interface_tx
148-
.send_message_with_response(
149-
ChainMessage::GetProposedBlock {
150-
previous_block: None,
151-
proposer: self.proposer.unwrap().to_bytes(),
152-
},
153-
)
154-
.await
155-
else {
156-
return Err(NodeError::Error(
157-
"Failed to get proposed block".to_string(),
158-
));
159-
};
160-
161-
if local_block == block {
162-
info!("Block is valid. Sending prevote.");
163-
self.send_vote(node, &block, VoteType::Prevote)?;
164-
} else {
165-
info!(
166-
"Block is invalid. Not voting - transaction mismatch"
167-
);
168-
info!(
169-
"Local txs: {:?}, Received txs: {:?}",
170-
local_block.body.transactions,
171-
block.body.transactions
172-
);
173-
}
174172
}
175-
Err(e) => warn!("Failed to deserialize block: {e}"),
176173
}
174+
Err(e) => warn!("Failed to deserialize block: {e}"),
177175
}
178-
_ => {}
179176
}
177+
_ => {}
180178
}
181179
}
182-
_ => {}
183180
}
181+
_ => {}
184182
}
185183
Ok(())
186184
}

‎crates/node/src/handlers/deposit/handler.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -19,17 +19,17 @@ impl<N: Network, W: Wallet> Handler<N, W> for DepositIntentState {
1919
async fn handle(
2020
&mut self,
2121
node: &mut NodeState<N, W>,
22-
message: Option<NetworkEvent>,
22+
message: NetworkEvent,
2323
) -> Result<(), types::errors::NodeError> {
2424
match message {
25-
Some(NetworkEvent::SelfRequest {
25+
NetworkEvent::SelfRequest {
2626
request:
2727
SelfRequest::CreateDeposit {
2828
user_pubkey,
2929
amount_sat,
3030
},
3131
response_channel,
32-
}) => {
32+
} => {
3333
println!("Node receveived request to create deposit");
3434
let response = self.create_deposit(node, &user_pubkey, amount_sat).await;
3535
if let Some(response_channel) = response_channel {
@@ -56,10 +56,10 @@ impl<N: Network, W: Wallet> Handler<N, W> for DepositIntentState {
5656
}
5757
}
5858
}
59-
Some(NetworkEvent::SelfRequest {
59+
NetworkEvent::SelfRequest {
6060
request: SelfRequest::GetPendingDepositIntents,
6161
response_channel,
62-
}) => {
62+
} => {
6363
let response = self.get_pending_deposit_intents(node).await;
6464
if let Some(response_channel) = response_channel {
6565
match response {
@@ -80,10 +80,10 @@ impl<N: Network, W: Wallet> Handler<N, W> for DepositIntentState {
8080
}
8181
}
8282
}
83-
Some(NetworkEvent::SelfRequest {
83+
NetworkEvent::SelfRequest {
8484
request: SelfRequest::ConfirmDeposit { confirmed_tx },
8585
..
86-
}) => {
86+
} => {
8787
info!(
8888
"🔔 Deposit handler received ConfirmDeposit event for tx: {}",
8989
confirmed_tx.compute_txid()
@@ -97,7 +97,7 @@ impl<N: Network, W: Wallet> Handler<N, W> for DepositIntentState {
9797
);
9898
}
9999
}
100-
Some(NetworkEvent::GossipsubMessage(Message { data, .. })) => {
100+
NetworkEvent::GossipsubMessage(Message { data, .. }) => {
101101
let broadcast = BroadcastMessage::decode(&data).map_err(|e| {
102102
NodeError::Error(format!("Failed to decode broadcast message: {e}"))
103103
})?;

‎crates/node/src/handlers/dkg/handler.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -11,15 +11,15 @@ impl<N: Network, W: Wallet> Handler<N, W> for DkgState {
1111
async fn handle(
1212
&mut self,
1313
node: &mut NodeState<N, W>,
14-
message: Option<NetworkEvent>,
14+
message: NetworkEvent,
1515
) -> Result<(), types::errors::NodeError> {
1616
match message {
17-
Some(NetworkEvent::Subscribed { peer_id, .. }) => {
17+
NetworkEvent::Subscribed { peer_id, .. } => {
1818
self.dkg_listeners.insert(peer_id);
1919
self.round1_listeners.insert(peer_id);
2020
self.handle_dkg_start(node)?;
2121
}
22-
Some(NetworkEvent::GossipsubMessage(message)) => {
22+
NetworkEvent::GossipsubMessage(message) => {
2323
if let Ok(BroadcastMessage::Dkg(gossip_msg)) =
2424
BroadcastMessage::decode(&message.data)
2525
{
@@ -38,7 +38,7 @@ impl<N: Network, W: Wallet> Handler<N, W> for DkgState {
3838
}
3939
}
4040
}
41-
Some(NetworkEvent::MessageEvent((peer, DirectMessage::Round2Package(package)))) => {
41+
NetworkEvent::MessageEvent((peer, DirectMessage::Round2Package(package))) => {
4242
self.handle_round2_payload(node, peer, package).await?;
4343
}
4444
_ => {}

‎crates/node/src/handlers/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ pub trait Handler<N: Network, W: Wallet>: Send + Any {
1717
async fn handle(
1818
&mut self,
1919
node: &mut NodeState<N, W>,
20-
message: Option<NetworkEvent>,
20+
message: NetworkEvent,
2121
) -> Result<(), NodeError>;
2222
}
2323

0 commit comments

Comments
 (0)