capnp ids

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

@@ -1,38 +0,0 @@
-use crate::crypto::*;
-use crate::*;
-use core::convert::TryInto;
-use rpc_processor::*;
-
-pub fn decode_block_id(public_key: &veilid_capnp::b_l_a_k_e3_hash::Reader) -> DHTKey {
-    let u0 = public_key.get_u0().to_be_bytes();
-    let u1 = public_key.get_u1().to_be_bytes();
-    let u2 = public_key.get_u2().to_be_bytes();
-    let u3 = public_key.get_u3().to_be_bytes();
-
-    let mut x: [u8; 32] = Default::default();
-    x[0..8].copy_from_slice(&u0);
-    x[8..16].copy_from_slice(&u1);
-    x[16..24].copy_from_slice(&u2);
-    x[24..32].copy_from_slice(&u3);
-
-    DHTKey::new(x)
-}
-
-pub fn encode_block_id(
-    key: &DHTKey,
-    builder: &mut veilid_capnp::b_l_a_k_e3_hash::Builder,
-) -> Result<(), RPCError> {
-    builder.set_u0(u64::from_be_bytes(
-        key.bytes[0..8].try_into().map_err(RPCError::internal)?,
-    ));
-    builder.set_u1(u64::from_be_bytes(
-        key.bytes[8..16].try_into().map_err(RPCError::internal)?,
-    ));
-    builder.set_u2(u64::from_be_bytes(
-        key.bytes[16..24].try_into().map_err(RPCError::internal)?,
-    ));
-    builder.set_u3(u64::from_be_bytes(
-        key.bytes[24..32].try_into().map_err(RPCError::internal)?,
-    ));
-    Ok(())
-}

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

@@ -3,7 +3,7 @@ use crate::*;
 use core::convert::TryInto;
 use rpc_processor::*;
 
-pub fn decode_public_key(public_key: &veilid_capnp::curve25519_public_key::Reader) -> DHTKey {
+pub fn decode_dht_key(public_key: &veilid_capnp::key256::Reader) -> DHTKey {
     let u0 = public_key.get_u0().to_be_bytes();
     let u1 = public_key.get_u1().to_be_bytes();
     let u2 = public_key.get_u2().to_be_bytes();
@@ -18,9 +18,9 @@ pub fn decode_public_key(public_key: &veilid_capnp::curve25519_public_key::Reade
     DHTKey::new(x)
 }
 
-pub fn encode_public_key(
+pub fn encode_dht_key(
     key: &DHTKey,
-    builder: &mut veilid_capnp::curve25519_public_key::Builder,
+    builder: &mut veilid_capnp::key256::Builder,
 ) -> Result<(), RPCError> {
     builder.set_u0(u64::from_be_bytes(
         key.bytes[0..8]

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

@@ -1,10 +1,7 @@
 use crate::*;
 use rpc_processor::*;
 
-pub fn encode_signature(
-    sig: &DHTSignature,
-    builder: &mut veilid_capnp::ed25519_signature::Builder,
-) {
+pub fn encode_signature(sig: &DHTSignature, builder: &mut veilid_capnp::signature512::Builder) {
     let sig = &sig.bytes;
 
     builder.set_u0(u64::from_be_bytes(
@@ -33,7 +30,7 @@ pub fn encode_signature(
     ));
 }
 
-pub fn decode_signature(reader: &veilid_capnp::ed25519_signature::Reader) -> DHTSignature {
+pub fn decode_signature(reader: &veilid_capnp::signature512::Reader) -> DHTSignature {
     let u0 = reader.get_u0().to_be_bytes();
     let u1 = reader.get_u1().to_be_bytes();
     let u2 = reader.get_u2().to_be_bytes();

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

@@ -1,6 +1,7 @@
 mod address;
 mod address_type_set;
-mod block_id;
+mod dht_key;
+mod dht_signature;
 mod dial_info;
 mod dial_info_class;
 mod dial_info_detail;
@@ -12,10 +13,8 @@ mod operations;
 mod peer_info;
 mod private_safety_route;
 mod protocol_type_set;
-mod public_key;
 mod sender_info;
 mod signal_info;
-mod signature;
 mod signed_direct_node_info;
 mod signed_node_info;
 mod signed_relayed_node_info;
@@ -26,7 +25,8 @@ mod value_key;
 
 pub use address::*;
 pub use address_type_set::*;
-pub use block_id::*;
+pub use dht_key::*;
+pub use dht_signature::*;
 pub use dial_info::*;
 pub use dial_info_class::*;
 pub use dial_info_detail::*;
@@ -38,10 +38,8 @@ pub use operations::*;
 pub use peer_info::*;
 pub use private_safety_route::*;
 pub use protocol_type_set::*;
-pub use public_key::*;
 pub use sender_info::*;
 pub use signal_info::*;
-pub use signature::*;
 pub use signed_direct_node_info::*;
 pub use signed_node_info::*;
 pub use signed_relayed_node_info::*;

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

@@ -1,10 +1,7 @@
 use crate::*;
 use rpc_processor::*;
 
-pub fn encode_nonce(
-    nonce: &Nonce,
-    builder: &mut veilid_capnp::x_cha_cha20_poly1305_nonce::Builder,
-) {
+pub fn encode_nonce(nonce: &Nonce, builder: &mut veilid_capnp::nonce24::Builder) {
     builder.set_u0(u64::from_be_bytes(
         nonce[0..8].try_into().expect("slice with incorrect length"),
     ));
@@ -20,7 +17,7 @@ pub fn encode_nonce(
     ));
 }
 
-pub fn decode_nonce(reader: &veilid_capnp::x_cha_cha20_poly1305_nonce::Reader) -> Nonce {
+pub fn decode_nonce(reader: &veilid_capnp::nonce24::Reader) -> Nonce {
     let u0 = reader.get_u0().to_be_bytes();
     let u1 = reader.get_u1().to_be_bytes();
     let u2 = reader.get_u2().to_be_bytes();

veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs

@@ -11,7 +11,7 @@ impl RPCOperationFindBlockQ {
         reader: &veilid_capnp::operation_find_block_q::Reader,
     ) -> Result<RPCOperationFindBlockQ, RPCError> {
         let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
-        let block_id = decode_block_id(&bi_reader);
+        let block_id = decode_dht_key(&bi_reader);
 
         Ok(RPCOperationFindBlockQ { block_id })
     }
@@ -20,7 +20,7 @@ impl RPCOperationFindBlockQ {
         builder: &mut veilid_capnp::operation_find_block_q::Builder,
     ) -> Result<(), RPCError> {
         let mut bi_builder = builder.reborrow().init_block_id();
-        encode_block_id(&self.block_id, &mut bi_builder)?;
+        encode_dht_key(&self.block_id, &mut bi_builder)?;
 
         Ok(())
     }

veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs

@@ -11,7 +11,7 @@ impl RPCOperationFindNodeQ {
         reader: &veilid_capnp::operation_find_node_q::Reader,
     ) -> Result<RPCOperationFindNodeQ, RPCError> {
         let ni_reader = reader.get_node_id().map_err(RPCError::protocol)?;
-        let node_id = decode_public_key(&ni_reader);
+        let node_id = decode_dht_key(&ni_reader);
         Ok(RPCOperationFindNodeQ { node_id })
     }
     pub fn encode(
@@ -19,7 +19,7 @@ impl RPCOperationFindNodeQ {
         builder: &mut veilid_capnp::operation_find_node_q::Builder,
     ) -> Result<(), RPCError> {
         let mut ni_builder = builder.reborrow().init_node_id();
-        encode_public_key(&self.node_id, &mut ni_builder)?;
+        encode_dht_key(&self.node_id, &mut ni_builder)?;
         Ok(())
     }
 }

veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs

@@ -11,7 +11,7 @@ impl RPCOperationSupplyBlockQ {
         reader: &veilid_capnp::operation_supply_block_q::Reader,
     ) -> Result<RPCOperationSupplyBlockQ, RPCError> {
         let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
-        let block_id = decode_block_id(&bi_reader);
+        let block_id = decode_dht_key(&bi_reader);
 
         Ok(RPCOperationSupplyBlockQ { block_id })
     }
@@ -20,7 +20,7 @@ impl RPCOperationSupplyBlockQ {
         builder: &mut veilid_capnp::operation_supply_block_q::Builder,
     ) -> Result<(), RPCError> {
         let mut bi_builder = builder.reborrow().init_block_id();
-        encode_block_id(&self.block_id, &mut bi_builder)?;
+        encode_dht_key(&self.block_id, &mut bi_builder)?;
 
         Ok(())
     }

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

@@ -7,7 +7,7 @@ pub fn encode_peer_info(
 ) -> Result<(), RPCError> {
     //
     let mut nid_builder = builder.reborrow().init_node_id();
-    encode_public_key(&peer_info.node_id.key, &mut nid_builder)?;
+    encode_dht_key(&peer_info.node_id.key, &mut nid_builder)?;
     let mut sni_builder = builder.reborrow().init_signed_node_info();
     encode_signed_node_info(&peer_info.signed_node_info, &mut sni_builder)?;
 
@@ -23,7 +23,7 @@ pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result<Peer
         .reborrow()
         .get_signed_node_info()
         .map_err(RPCError::protocol)?;
-    let node_id = NodeId::new(decode_public_key(&nid_reader));
+    let node_id = NodeId::new(decode_dht_key(&nid_reader));
     let signed_node_info = decode_signed_node_info(&sni_reader, &node_id.key)?;
 
     Ok(PeerInfo {

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

@@ -53,7 +53,7 @@ pub fn encode_route_hop(
     match &route_hop.node {
         RouteNode::NodeId(ni) => {
             let mut ni_builder = node_builder.init_node_id();
-            encode_public_key(&ni.key, &mut ni_builder)?;
+            encode_dht_key(&ni.key, &mut ni_builder)?;
         }
         RouteNode::PeerInfo(pi) => {
             let mut pi_builder = node_builder.init_peer_info();
@@ -72,7 +72,7 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
     let node = match n_reader.which().map_err(RPCError::protocol)? {
         veilid_capnp::route_hop::node::Which::NodeId(ni) => {
             let ni_reader = ni.map_err(RPCError::protocol)?;
-            RouteNode::NodeId(NodeId::new(decode_public_key(&ni_reader)))
+            RouteNode::NodeId(NodeId::new(decode_dht_key(&ni_reader)))
         }
         veilid_capnp::route_hop::node::Which::PeerInfo(pi) => {
             let pi_reader = pi.map_err(RPCError::protocol)?;
@@ -101,7 +101,7 @@ pub fn encode_private_route(
     private_route: &PrivateRoute,
     builder: &mut veilid_capnp::private_route::Builder,
 ) -> Result<(), RPCError> {
-    encode_public_key(
+    encode_dht_key(
         &private_route.public_key,
         &mut builder.reborrow().init_public_key(),
     )?;
@@ -117,9 +117,9 @@ pub fn encode_private_route(
 pub fn decode_private_route(
     reader: &veilid_capnp::private_route::Reader,
 ) -> Result<PrivateRoute, RPCError> {
-    let public_key = decode_public_key(&reader.get_public_key().map_err(
-        RPCError::map_protocol("invalid public key in private route"),
-    )?);
+    let public_key = decode_dht_key(&reader.get_public_key().map_err(RPCError::map_protocol(
+        "invalid public key in private route",
+    ))?);
     let hop_count = reader.get_hop_count();
     let first_hop = if reader.has_first_hop() {
         let rh_reader = reader
@@ -143,7 +143,7 @@ pub fn encode_safety_route(
     safety_route: &SafetyRoute,
     builder: &mut veilid_capnp::safety_route::Builder,
 ) -> Result<(), RPCError> {
-    encode_public_key(
+    encode_dht_key(
         &safety_route.public_key,
         &mut builder.reborrow().init_public_key(),
     )?;
@@ -166,7 +166,7 @@ pub fn encode_safety_route(
 pub fn decode_safety_route(
     reader: &veilid_capnp::safety_route::Reader,
 ) -> Result<SafetyRoute, RPCError> {
-    let public_key = decode_public_key(
+    let public_key = decode_dht_key(
         &reader
             .get_public_key()
             .map_err(RPCError::map_protocol("invalid public key in safety route"))?,

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

@@ -10,7 +10,7 @@ pub fn encode_signed_relayed_node_info(
     encode_node_info(&signed_relayed_node_info.node_info, &mut ni_builder)?;
 
     let mut rid_builder = builder.reborrow().init_relay_id();
-    encode_public_key(&signed_relayed_node_info.relay_id.key, &mut rid_builder)?;
+    encode_dht_key(&signed_relayed_node_info.relay_id.key, &mut rid_builder)?;
 
     let mut ri_builder = builder.reborrow().init_relay_info();
     encode_signed_direct_node_info(&signed_relayed_node_info.relay_info, &mut ri_builder)?;
@@ -39,7 +39,7 @@ pub fn decode_signed_relayed_node_info(
         .reborrow()
         .get_relay_id()
         .map_err(RPCError::protocol)?;
-    let relay_id = decode_public_key(&rid_reader);
+    let relay_id = decode_dht_key(&rid_reader);
 
     let ri_reader = reader
         .reborrow()

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

@@ -6,7 +6,7 @@ pub fn encode_value_key(
     builder: &mut veilid_capnp::value_key::Builder,
 ) -> Result<(), RPCError> {
     let mut pk_builder = builder.reborrow().init_public_key();
-    encode_public_key(&value_key.key, &mut pk_builder)?;
+    encode_dht_key(&value_key.key, &mut pk_builder)?;
     if let Some(subkey) = &value_key.subkey {
         builder.set_subkey(subkey);
     }
@@ -15,7 +15,7 @@ pub fn encode_value_key(
 
 pub fn decode_value_key(reader: &veilid_capnp::value_key::Reader) -> Result<ValueKey, RPCError> {
     let pk_reader = reader.get_public_key().map_err(RPCError::protocol)?;
-    let key = decode_public_key(&pk_reader);
+    let key = decode_dht_key(&pk_reader);
     let subkey = if !reader.has_subkey() {
         None
     } else {