liz/veilid
1
0
Fork 0
Code Pull Requests Packages Releases Activity

checkpoint

Browse Source
This commit is contained in:
John Smith
2023-02-08 16:50:07 -05:00
parent a58a87719c
commit 764b629714
29 changed files with 434 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
veilid-core/src/rpc_processor/coders/dht_key.rs → veilid-core/src/rpc_processor/coders/key256.rs
View File

@@ -1,7 +1,7 @@
use super::*;
use core::convert::TryInto;
pub fn decode_dht_key(public_key: &veilid_capnp::key256::Reader) -> PublicKey {
pub fn decode_key256(public_key: &veilid_capnp::key256::Reader) -> PublicKey {
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();
@@ -16,29 +16,25 @@ pub fn decode_dht_key(public_key: &veilid_capnp::key256::Reader) -> PublicKey {
PublicKey::new(x)
}
pub fn encode_dht_key(
key: &PublicKey,
builder: &mut veilid_capnp::key256::Builder,
) -> Result<(), RPCError> {
pub fn encode_key256(key: &PublicKey, builder: &mut veilid_capnp::key256::Builder) {
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
.expect("slice with incorrect length"),
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
.expect("slice with incorrect length"),
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
.expect("slice with incorrect length"),
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
.expect("slice with incorrect length"),
));
Ok(())
}

14
veilid-core/src/rpc_processor/coders/mod.rs
View File

@@ -1,10 +1,9 @@
mod address;
mod address_type_set;
mod dht_key;
mod dht_signature;
mod dial_info;
mod dial_info_class;
mod dial_info_detail;
mod key256;
mod network_class;
mod node_info;
mod node_status;
@@ -16,21 +15,22 @@ mod protocol_type_set;
mod sender_info;
mod sequencing;
mod signal_info;
mod signature512;
mod signed_direct_node_info;
mod signed_node_info;
mod signed_relayed_node_info;
mod socket_address;
mod tunnel;
mod typed_key;
mod typed_signature;
mod value_data;
mod value_key;
pub use address::*;
pub use address_type_set::*;
pub use dht_key::*;
pub use dht_signature::*;
pub use dial_info::*;
pub use dial_info_class::*;
pub use dial_info_detail::*;
pub use key256::*;
pub use network_class::*;
pub use node_info::*;
pub use node_status::*;
@@ -42,12 +42,14 @@ pub use protocol_type_set::*;
pub use sender_info::*;
pub use sequencing::*;
pub use signal_info::*;
pub use signature512::*;
pub use signed_direct_node_info::*;
pub use signed_node_info::*;
pub use signed_relayed_node_info::*;
pub use socket_address::*;
pub use tunnel::*;
pub use typed_key::*;
pub use typed_signature::*;
pub use value_data::*;
pub use value_key::*;
use super::*;

41
veilid-core/src/rpc_processor/coders/node_info.rs
View File

@@ -12,8 +12,24 @@ pub fn encode_node_info(
let mut ats_builder = builder.reborrow().init_address_types();
encode_address_type_set(&node_info.address_types, &mut ats_builder)?;
builder.set_min_version(node_info.min_version);
builder.set_max_version(node_info.max_version);
let mut es_builder = builder
.reborrow()
.init_envelope_support(node_info.envelope_support.len() as u32);
if let Some(s) = es_builder.as_slice() {
s.clone_from_slice(&node_info.envelope_support);
}
let mut cs_builder = builder
.reborrow()
.init_crypto_support(node_info.crypto_support.len() as u32);
if let Some(s) = cs_builder.as_slice() {
let csvec: Vec<u32> = node_info
.crypto_support
.iter()
.map(|x| u32::from_be_bytes(x.0))
.collect();
s.clone_from_slice(&csvec);
}
let mut didl_builder = builder.reborrow().init_dial_info_detail_list(
node_info
@@ -55,8 +71,21 @@ pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<Node
.map_err(RPCError::protocol)?,
)?;
let min_version = reader.reborrow().get_min_version();
let max_version = reader.reborrow().get_max_version();
let envelope_support = reader
.reborrow()
.get_envelope_support()
.map_err(RPCError::protocol)?
.as_slice()
.map(|s| s.to_vec())
.unwrap_or_default();
let crypto_support: Vec<CryptoKind> = reader
.reborrow()
.get_crypto_support()
.map_err(RPCError::protocol)?
.as_slice()
.map(|s| s.iter().map(|x| FourCC::from(x.to_be_bytes())).collect())
.unwrap_or_default();
let didl_reader = reader
.reborrow()
@@ -76,8 +105,8 @@ pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<Node
network_class,
outbound_protocols,
address_types,
min_version,
max_version,
envelope_support,
crypto_support,
dial_info_detail_list,
})
}

12
veilid-core/src/rpc_processor/coders/nonce.rs
View File

@@ -2,15 +2,17 @@ use super::*;
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"),
nonce.bytes[0..8]
.try_into()
.expect("slice with incorrect length"),
));
builder.set_u1(u64::from_be_bytes(
nonce[8..16]
nonce.bytes[8..16]
.try_into()
.expect("slice with incorrect length"),
));
builder.set_u2(u64::from_be_bytes(
nonce[16..24]
nonce.bytes[16..24]
.try_into()
.expect("slice with incorrect length"),
));
@@ -21,9 +23,9 @@ pub fn decode_nonce(reader: &veilid_capnp::nonce24::Reader) -> Nonce {
let u1 = reader.get_u1().to_be_bytes();
let u2 = reader.get_u2().to_be_bytes();
[
Nonce::new([
u0[0], u0[1], u0[2], u0[3], u0[4], u0[5], u0[6], u0[7], // u0
u1[0], u1[1], u1[2], u1[3], u1[4], u1[5], u1[6], u1[7], // u1
u2[0], u2[1], u2[2], u2[3], u2[4], u2[5], u2[6], u2[7], // u2
]
])
}

4
veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs
View File

@@ -10,7 +10,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_dht_key(&bi_reader);
let block_id = decode_key256(&bi_reader);
Ok(RPCOperationFindBlockQ { block_id })
}
@@ -19,7 +19,7 @@ impl RPCOperationFindBlockQ {
builder: &mut veilid_capnp::operation_find_block_q::Builder,
) -> Result<(), RPCError> {
let mut bi_builder = builder.reborrow().init_block_id();
encode_dht_key(&self.block_id, &mut bi_builder)?;
encode_key256(&self.block_id, &mut bi_builder)?;
Ok(())
}

4
veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs
View File

@@ -10,7 +10,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_dht_key(&ni_reader);
let node_id = decode_key256(&ni_reader);
Ok(RPCOperationFindNodeQ { node_id })
}
pub fn encode(
@@ -18,7 +18,7 @@ impl RPCOperationFindNodeQ {
builder: &mut veilid_capnp::operation_find_node_q::Builder,
) -> Result<(), RPCError> {
let mut ni_builder = builder.reborrow().init_node_id();
encode_dht_key(&self.node_id, &mut ni_builder)?;
encode_key256(&self.node_id, &mut ni_builder)?;
Ok(())
}
}

4
veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs
View File

@@ -10,7 +10,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_dht_key(&bi_reader);
let block_id = decode_key256(&bi_reader);
Ok(RPCOperationSupplyBlockQ { block_id })
}
@@ -19,7 +19,7 @@ impl RPCOperationSupplyBlockQ {
builder: &mut veilid_capnp::operation_supply_block_q::Builder,
) -> Result<(), RPCError> {
let mut bi_builder = builder.reborrow().init_block_id();
encode_dht_key(&self.block_id, &mut bi_builder)?;
encode_key256(&self.block_id, &mut bi_builder)?;
Ok(())
}

36
veilid-core/src/rpc_processor/coders/peer_info.rs
View File

@@ -5,28 +5,48 @@ pub fn encode_peer_info(
builder: &mut veilid_capnp::peer_info::Builder,
) -> Result<(), RPCError> {
//
let mut nid_builder = builder.reborrow().init_node_id();
encode_dht_key(&peer_info.node_id.key, &mut nid_builder)?;
let mut nids_builder = builder.reborrow().init_node_ids(
peer_info
.node_ids
.len()
.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
);
for (i, nid) in peer_info.node_ids.iter().enumerate() {
encode_typed_key(
nid,
&mut nids_builder.get(
i.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
),
);
}
let mut sni_builder = builder.reborrow().init_signed_node_info();
encode_signed_node_info(&peer_info.signed_node_info, &mut sni_builder)?;
Ok(())
}
pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result<PeerInfo, RPCError> {
let nid_reader = reader
pub fn decode_peer_info(
reader: &veilid_capnp::peer_info::Reader,
crypto: Crypto,
) -> Result<PeerInfo, RPCError> {
let nids_reader = reader
.reborrow()
.get_node_id()
.get_node_ids()
.map_err(RPCError::protocol)?;
let sni_reader = reader
.reborrow()
.get_signed_node_info()
.map_err(RPCError::protocol)?;
let node_id = NodeId::new(decode_dht_key(&nid_reader));
let signed_node_info = decode_signed_node_info(&sni_reader, &node_id.key)?;
let node_ids = Vec::with_capacity(nids_reader.len() as usize);
for nid_reader in nids_reader.iter() {
node_ids.push(decode_typed_key(&nid_reader)?);
}
let signed_node_info = decode_signed_node_info(&sni_reader, crypto, &node_ids)?;
Ok(PeerInfo {
node_id,
node_ids,
signed_node_info,
})
}

12
veilid-core/src/rpc_processor/coders/private_safety_route.rs
View File

@@ -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_dht_key(&ni.key, &mut ni_builder)?;
encode_key256(&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_dht_key(&ni_reader)))
RouteNode::NodeId(NodeId::new(decode_key256(&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_dht_key(
encode_key256(
&private_route.public_key,
&mut builder.reborrow().init_public_key(),
)?;
@@ -126,7 +126,7 @@ pub fn encode_private_route(
pub fn decode_private_route(
reader: &veilid_capnp::private_route::Reader,
) -> Result<PrivateRoute, RPCError> {
let public_key = decode_dht_key(&reader.get_public_key().map_err(RPCError::map_protocol(
let public_key = decode_key256(&reader.get_public_key().map_err(RPCError::map_protocol(
"invalid public key in private route",
))?);
let hop_count = reader.get_hop_count();
@@ -156,7 +156,7 @@ pub fn encode_safety_route(
safety_route: &SafetyRoute,
builder: &mut veilid_capnp::safety_route::Builder,
) -> Result<(), RPCError> {
encode_dht_key(
encode_key256(
&safety_route.public_key,
&mut builder.reborrow().init_public_key(),
)?;
@@ -179,7 +179,7 @@ pub fn encode_safety_route(
pub fn decode_safety_route(
reader: &veilid_capnp::safety_route::Reader,
) -> Result<SafetyRoute, RPCError> {
let public_key = decode_dht_key(
let public_key = decode_key256(
&reader
.get_public_key()
.map_err(RPCError::map_protocol("invalid public key in safety route"))?,

4
veilid-core/src/rpc_processor/coders/dht_signature.rs → veilid-core/src/rpc_processor/coders/signature512.rs
View File

@@ -1,6 +1,6 @@
use super::*;
pub fn encode_signature(sig: &Signature, builder: &mut veilid_capnp::signature512::Builder) {
pub fn encode_signature512(sig: &Signature, builder: &mut veilid_capnp::signature512::Builder) {
let sig = &sig.bytes;
builder.set_u0(u64::from_be_bytes(
@@ -29,7 +29,7 @@ pub fn encode_signature(sig: &Signature, builder: &mut veilid_capnp::signature51
));
}
pub fn decode_signature(reader: &veilid_capnp::signature512::Reader) -> Signature {
pub fn decode_signature512(reader: &veilid_capnp::signature512::Reader) -> Signature {
let u0 = reader.get_u0().to_be_bytes();
let u1 = reader.get_u1().to_be_bytes();
let u2 = reader.get_u2().to_be_bytes();

36
veilid-core/src/rpc_processor/coders/signed_direct_node_info.rs
View File

@@ -12,18 +12,30 @@ pub fn encode_signed_direct_node_info(
.reborrow()
.set_timestamp(signed_direct_node_info.timestamp.into());
let mut sig_builder = builder.reborrow().init_signature();
let Some(signature) = &signed_direct_node_info.signature else {
return Err(RPCError::internal("Should not encode SignedDirectNodeInfo without signature!"));
};
encode_signature(signature, &mut sig_builder);
let mut sigs_builder = builder.reborrow().init_signatures(
signed_direct_node_info
.signatures
.len()
.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
);
for (i, typed_signature) in signed_direct_node_info.signatures.iter().enumerate() {
encode_typed_signature(
typed_signature,
&mut sigs_builder.get(
i.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
),
);
}
Ok(())
}
pub fn decode_signed_direct_node_info(
reader: &veilid_capnp::signed_direct_node_info::Reader,
node_id: &PublicKey,
crypto: Crypto,
node_ids: &[TypedKey],
) -> Result<SignedDirectNodeInfo, RPCError> {
let ni_reader = reader
.reborrow()
@@ -31,15 +43,19 @@ pub fn decode_signed_direct_node_info(
.map_err(RPCError::protocol)?;
let node_info = decode_node_info(&ni_reader)?;
let sig_reader = reader
let sigs_reader = reader
.reborrow()
.get_signature()
.get_signatures()
.map_err(RPCError::protocol)?;
let timestamp = reader.reborrow().get_timestamp().into();
let signature = decode_signature(&sig_reader);
let mut typed_signatures = Vec::with_capacity(sigs_reader.len() as usize);
for sig_reader in sigs_reader {
let typed_signature = decode_typed_signature(&sig_reader)?;
typed_signatures.push(typed_signature);
}
SignedDirectNodeInfo::new(NodeId::new(*node_id), node_info, timestamp, signature)
SignedDirectNodeInfo::new(crypto, node_ids, node_info, timestamp, typed_signatures)
.map_err(RPCError::protocol)
}

9
veilid-core/src/rpc_processor/coders/signed_node_info.rs
View File

@@ -20,20 +20,21 @@ pub fn encode_signed_node_info(
pub fn decode_signed_node_info(
reader: &veilid_capnp::signed_node_info::Reader,
node_id: &PublicKey,
crypto: Crypto,
node_ids: &[TypedKey],
) -> Result<SignedNodeInfo, RPCError> {
match reader
.which()
.map_err(RPCError::map_internal("invalid signal operation"))?
.map_err(RPCError::map_internal("invalid signed node info"))?
{
veilid_capnp::signed_node_info::Direct(d) => {
let d_reader = d.map_err(RPCError::protocol)?;
let sdni = decode_signed_direct_node_info(&d_reader, node_id)?;
let sdni = decode_signed_direct_node_info(&d_reader, crypto, node_ids)?;
Ok(SignedNodeInfo::Direct(sdni))
}
veilid_capnp::signed_node_info::Relayed(r) => {
let r_reader = r.map_err(RPCError::protocol)?;
let srni = decode_signed_relayed_node_info(&r_reader, node_id)?;
let srni = decode_signed_relayed_node_info(&r_reader, crypto, node_ids)?;
Ok(SignedNodeInfo::Relayed(srni))
}
}

70
veilid-core/src/rpc_processor/coders/signed_relayed_node_info.rs
View File

@@ -8,8 +8,22 @@ pub fn encode_signed_relayed_node_info(
let mut ni_builder = builder.reborrow().init_node_info();
encode_node_info(&signed_relayed_node_info.node_info, &mut ni_builder)?;
let mut rid_builder = builder.reborrow().init_relay_id();
encode_dht_key(&signed_relayed_node_info.relay_id.key, &mut rid_builder)?;
let mut rids_builder = builder.reborrow().init_relay_ids(
signed_relayed_node_info
.relay_ids
.len()
.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
);
for (i, typed_key) in signed_relayed_node_info.relay_ids.iter().enumerate() {
encode_typed_key(
typed_key,
&mut rids_builder.get(
i.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
),
);
}
let mut ri_builder = builder.reborrow().init_relay_info();
encode_signed_direct_node_info(&signed_relayed_node_info.relay_info, &mut ri_builder)?;
@@ -18,15 +32,30 @@ pub fn encode_signed_relayed_node_info(
.reborrow()
.set_timestamp(signed_relayed_node_info.timestamp.into());
let mut sig_builder = builder.reborrow().init_signature();
encode_signature(&signed_relayed_node_info.signature, &mut sig_builder);
let mut sigs_builder = builder.reborrow().init_signatures(
signed_relayed_node_info
.signatures
.len()
.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
);
for (i, typed_signature) in signed_relayed_node_info.signatures.iter().enumerate() {
encode_typed_signature(
typed_signature,
&mut sigs_builder.get(
i.try_into()
.map_err(RPCError::map_invalid_format("out of bound error"))?,
),
);
}
Ok(())
}
pub fn decode_signed_relayed_node_info(
reader: &veilid_capnp::signed_relayed_node_info::Reader,
node_id: &PublicKey,
crypto: Crypto,
node_ids: &[TypedKey],
) -> Result<SignedRelayedNodeInfo, RPCError> {
let ni_reader = reader
.reborrow()
@@ -34,33 +63,42 @@ pub fn decode_signed_relayed_node_info(
.map_err(RPCError::protocol)?;
let node_info = decode_node_info(&ni_reader)?;
let rid_reader = reader
let rids_reader = reader
.reborrow()
.get_relay_id()
.get_relay_ids()
.map_err(RPCError::protocol)?;
let relay_id = decode_dht_key(&rid_reader);
let mut relay_ids = Vec::with_capacity(rids_reader.len() as usize);
for rid_reader in rids_reader {
let relay_id = decode_typed_key(&rid_reader)?;
relay_ids.push(relay_id);
}
let ri_reader = reader
.reborrow()
.get_relay_info()
.map_err(RPCError::protocol)?;
let relay_info = decode_signed_direct_node_info(&ri_reader, &relay_id)?;
let relay_info = decode_signed_direct_node_info(&ri_reader, crypto, &relay_ids)?;
let sig_reader = reader
let sigs_reader = reader
.reborrow()
.get_signature()
.get_signatures()
.map_err(RPCError::protocol)?;
let timestamp = reader.reborrow().get_timestamp().into();
let signature = decode_signature(&sig_reader);
let mut typed_signatures = Vec::with_capacity(sigs_reader.len() as usize);
for sig_reader in sigs_reader {
let typed_signature = decode_typed_signature(&sig_reader)?;
typed_signatures.push(typed_signature);
}
SignedRelayedNodeInfo::new(
NodeId::new(*node_id),
crypto,
node_ids,
node_info,
NodeId::new(relay_id),
relay_ids,
relay_info,
timestamp,
signature,
typed_signatures,
)
.map_err(RPCError::protocol)
}

19
veilid-core/src/rpc_processor/coders/typed_key.rs Normal file
View File

@@ -0,0 +1,19 @@
use super::*;
pub fn decode_typed_key(typed_key: &veilid_capnp::typed_key::Reader) -> Result<TypedKey, RPCError> {
let key_reader = typed_key
.get_key()
.map_err(RPCError::map_invalid_format("invalid typed key"))?;
let kind = typed_key.get_kind();
Ok(TypedKey::new(
CryptoKind::from(kind.to_be_bytes()),
decode_key256(&key_reader),
))
}
pub fn encode_typed_key(typed_key: &TypedKey, builder: &mut veilid_capnp::typed_key::Builder) {
builder.set_kind(u32::from_be_bytes(typed_key.kind.0));
let mut key_builder = builder.init_key();
encode_key256(&typed_key.key, &mut key_builder);
}

24
veilid-core/src/rpc_processor/coders/typed_signature.rs Normal file
View File

@@ -0,0 +1,24 @@
use super::*;
pub fn decode_typed_signature(
typed_signature: &veilid_capnp::typed_signature::Reader,
) -> Result<TypedSignature, RPCError> {
let sig_reader = typed_signature
.get_signature()
.map_err(RPCError::map_invalid_format("invalid typed signature"))?;
let kind = typed_signature.get_kind();
Ok(TypedSignature::new(
CryptoKind::from(kind.to_be_bytes()),
decode_signature512(&sig_reader),
))
}
pub fn encode_typed_signature(
typed_signature: &TypedSignature,
builder: &mut veilid_capnp::typed_signature::Builder,
) {
builder.set_kind(u32::from_be_bytes(typed_signature.kind.0));
let mut sig_builder = builder.init_signature();
encode_signature512(&typed_signature.signature, &mut sig_builder);
}

25
veilid-core/src/rpc_processor/coders/value_key.rs
View File

@@ -1,25 +0,0 @@
use super::*;
pub fn encode_value_key(
value_key: &ValueKey,
builder: &mut veilid_capnp::value_key::Builder,
) -> Result<(), RPCError> {
let mut pk_builder = builder.reborrow().init_public_key();
encode_dht_key(&value_key.key, &mut pk_builder)?;
if let Some(subkey) = &value_key.subkey {
builder.set_subkey(subkey);
}
Ok(())
}
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_dht_key(&pk_reader);
let subkey = if !reader.has_subkey() {
None
} else {
let subkey = reader.get_subkey().map_err(RPCError::protocol)?;
Some(subkey.to_owned())
};
Ok(ValueKey { key, subkey })
}