clippy work

veilid-core/src/rpc_processor/coders/private_safety_route.rs

@@ -76,10 +76,10 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
         }
         veilid_capnp::route_hop::node::Which::PeerInfo(pi) => {
             let pi_reader = pi.map_err(RPCError::protocol)?;
-            RouteNode::PeerInfo(
+            RouteNode::PeerInfo(Box::new(
                 decode_peer_info(&pi_reader)
                     .map_err(RPCError::map_protocol("invalid peer info in route hop"))?,
-            )
+            ))
         }
     };
 
@@ -134,7 +134,7 @@ pub fn decode_private_route(
     let hops = match reader.get_hops().which().map_err(RPCError::protocol)? {
         veilid_capnp::private_route::hops::Which::FirstHop(rh_reader) => {
             let rh_reader = rh_reader.map_err(RPCError::protocol)?;
-            PrivateRouteHops::FirstHop(decode_route_hop(&rh_reader)?)
+            PrivateRouteHops::FirstHop(Box::new(decode_route_hop(&rh_reader)?))
         }
         veilid_capnp::private_route::hops::Which::Data(rhd_reader) => {
             let rhd_reader = rhd_reader.map_err(RPCError::protocol)?;

veilid-core/src/rpc_processor/destination.rs

@@ -181,10 +181,17 @@ impl RPCProcessor {
                     // Sent directly but with a safety route, respond to private route
                     let crypto_kind = target.best_node_id().kind;
                     let Some(pr_key) = rss
-                            .get_private_route_for_safety_spec(crypto_kind, safety_spec, &target.node_ids())
-                            .map_err(RPCError::internal)? else {
-                                return Ok(NetworkResult::no_connection_other("no private route for response at this time"));
-                            };
+                        .get_private_route_for_safety_spec(
+                            crypto_kind,
+                            safety_spec,
+                            &target.node_ids(),
+                        )
+                        .map_err(RPCError::internal)?
+                    else {
+                        return Ok(NetworkResult::no_connection_other(
+                            "no private route for response at this time",
+                        ));
+                    };
 
                     // Get the assembled route for response
                     let private_route = rss
@@ -211,9 +218,12 @@ impl RPCProcessor {
                     avoid_nodes.add_all(&target.node_ids());
                     let Some(pr_key) = rss
                         .get_private_route_for_safety_spec(crypto_kind, safety_spec, &avoid_nodes)
-                        .map_err(RPCError::internal)? else {
-                            return Ok(NetworkResult::no_connection_other("no private route for response at this time"));
-                        };
+                        .map_err(RPCError::internal)?
+                    else {
+                        return Ok(NetworkResult::no_connection_other(
+                            "no private route for response at this time",
+                        ));
+                    };
 
                     // Get the assembled route for response
                     let private_route = rss
@@ -228,7 +238,9 @@ impl RPCProcessor {
                 safety_selection,
             } => {
                 let Some(avoid_node_id) = private_route.first_hop_node_id() else {
-                    return Err(RPCError::internal("destination private route must have first hop"));
+                    return Err(RPCError::internal(
+                        "destination private route must have first hop",
+                    ));
                 };
 
                 let crypto_kind = private_route.public_key.kind;
@@ -250,7 +262,7 @@ impl RPCProcessor {
                         } else {
                             let own_peer_info =
                                 routing_table.get_own_peer_info(RoutingDomain::PublicInternet);
-                            RouteNode::PeerInfo(own_peer_info)
+                            RouteNode::PeerInfo(Box::new(own_peer_info))
                         };
 
                         Ok(NetworkResult::value(RespondTo::PrivateRoute(
@@ -271,10 +283,17 @@ impl RPCProcessor {
                         } else {
                             // Get the private route to respond to that matches the safety route spec we sent the request with
                             let Some(pr_key) = rss
-                                .get_private_route_for_safety_spec(crypto_kind, safety_spec, &[avoid_node_id])
-                                .map_err(RPCError::internal)? else {
-                                    return Ok(NetworkResult::no_connection_other("no private route for response at this time"));
-                                };
+                                .get_private_route_for_safety_spec(
+                                    crypto_kind,
+                                    safety_spec,
+                                    &[avoid_node_id],
+                                )
+                                .map_err(RPCError::internal)?
+                            else {
+                                return Ok(NetworkResult::no_connection_other(
+                                    "no private route for response at this time",
+                                ));
+                            };
                             pr_key
                         };
 

veilid-core/src/rpc_processor/mod.rs

@@ -812,7 +812,7 @@ impl RPCProcessor {
                         };
                         let private_route = PrivateRoute::new_stub(
                             destination_node_ref.best_node_id(),
-                            RouteNode::PeerInfo(peer_info),
+                            RouteNode::PeerInfo(Box::new(peer_info)),
                         );
 
                         // Wrap with safety route