325 lines
10 KiB
Rust
325 lines
10 KiB
Rust
use crate::entry::Attribute;
|
|
use crate::error::{AddressComponentsDecodeError, UpEndError};
|
|
use crate::hash::{
|
|
b58_decode, b58_encode, AsMultihash, AsMultihashError, LargeMultihash, UpMultihash, IDENTITY,
|
|
};
|
|
use serde::de::Visitor;
|
|
use serde::{de, ser, Deserialize, Deserializer, Serialize, Serializer};
|
|
use std::convert::TryFrom;
|
|
use std::fmt;
|
|
use std::hash::Hash;
|
|
use std::str::FromStr;
|
|
use url::Url;
|
|
use uuid::Uuid;
|
|
|
|
#[cfg(feature = "wasm")]
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
#[derive(Clone, Eq, PartialEq, Hash)]
|
|
pub enum Address {
|
|
Hash(UpMultihash),
|
|
Uuid(Uuid),
|
|
Attribute(Attribute),
|
|
Url(Url),
|
|
}
|
|
|
|
#[cfg_attr(feature = "wasm", wasm_bindgen(getter_with_clone, inspectable))]
|
|
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
|
|
pub struct AddressComponents {
|
|
pub t: String,
|
|
pub c: Option<String>,
|
|
}
|
|
|
|
#[cfg(feature = "wasm")]
|
|
#[wasm_bindgen]
|
|
impl AddressComponents {
|
|
#[wasm_bindgen(constructor)]
|
|
pub fn new(t: String, c: Option<String>) -> Self {
|
|
AddressComponents { t, c }
|
|
}
|
|
}
|
|
|
|
/// multicodec RAW code
|
|
const RAW: u64 = 0x55;
|
|
|
|
/// multicodec UpEnd UUID code (reserved area)
|
|
const UP_UUID: u64 = 0x300001;
|
|
|
|
/// multicodec UpEnd Attribute code (reserved area)
|
|
const UP_ATTRIBUTE: u64 = 0x300000;
|
|
|
|
/// multicodec URL code (technically `http`)
|
|
const UP_URL: u64 = 0x01e0;
|
|
|
|
pub type UpCid = cid::CidGeneric<256>;
|
|
|
|
impl Address {
|
|
pub fn encode(&self) -> Result<Vec<u8>, UpEndError> {
|
|
let (codec, hash) = match self {
|
|
Self::Hash(hash) => (RAW, hash.into()),
|
|
Self::Uuid(uuid) => (
|
|
UP_UUID,
|
|
LargeMultihash::wrap(IDENTITY, uuid.as_bytes()).map_err(UpEndError::from_any)?,
|
|
),
|
|
Self::Attribute(attribute) => (
|
|
UP_ATTRIBUTE,
|
|
LargeMultihash::wrap(IDENTITY, attribute.to_string().as_bytes())
|
|
.map_err(UpEndError::from_any)?,
|
|
),
|
|
Self::Url(url) => (
|
|
UP_URL,
|
|
LargeMultihash::wrap(IDENTITY, url.to_string().as_bytes())
|
|
.map_err(UpEndError::from_any)?,
|
|
),
|
|
};
|
|
|
|
let cid = UpCid::new_v1(codec, hash);
|
|
|
|
Ok(cid.to_bytes())
|
|
}
|
|
|
|
pub fn decode(buffer: &[u8]) -> Result<Self, UpEndError> {
|
|
let cid = UpCid::try_from(buffer).map_err(|err| {
|
|
UpEndError::AddressParseError(format!("Error decoding address: {}", err))
|
|
})?;
|
|
|
|
if cid.codec() == RAW {
|
|
return Ok(Address::Hash(UpMultihash::from(*cid.hash())));
|
|
}
|
|
|
|
let hash = cid.hash();
|
|
|
|
if hash.code() != IDENTITY {
|
|
return Err(UpEndError::AddressParseError(format!(
|
|
"Unexpected multihash code \"{}\" for codec \"{}\"",
|
|
hash.code(),
|
|
cid.codec()
|
|
)));
|
|
}
|
|
|
|
let digest = cid.hash().digest().to_vec();
|
|
|
|
match cid.codec() {
|
|
UP_UUID => Ok(Address::Uuid(
|
|
Uuid::from_slice(digest.as_slice()).map_err(UpEndError::from_any)?,
|
|
)),
|
|
UP_ATTRIBUTE => {
|
|
let attribute = String::from_utf8(digest).map_err(UpEndError::from_any)?;
|
|
if attribute.is_empty() {
|
|
Ok(Address::Attribute(Attribute::null()))
|
|
} else {
|
|
Ok(Address::Attribute(attribute.parse()?))
|
|
}
|
|
}
|
|
UP_URL => Ok(Address::Url(
|
|
Url::parse(&String::from_utf8(digest).map_err(UpEndError::from_any)?)
|
|
.map_err(UpEndError::from_any)?,
|
|
)),
|
|
_ => Err(UpEndError::AddressParseError(
|
|
"Error decoding address: Unknown codec.".to_string(),
|
|
)),
|
|
}
|
|
}
|
|
|
|
pub fn as_components(&self) -> AddressComponents {
|
|
// TODO: make this automatically derive from `Address` definition
|
|
let (entity_type, entity_content) = match self {
|
|
Address::Hash(uphash) => ("Hash", Some(b58_encode(uphash.to_bytes()))),
|
|
Address::Uuid(uuid) => ("Uuid", Some(uuid.to_string())),
|
|
Address::Attribute(attribute) => ("Attribute", Some(attribute.to_string())),
|
|
Address::Url(url) => ("Url", Some(url.to_string())),
|
|
};
|
|
|
|
AddressComponents {
|
|
t: entity_type.to_string(),
|
|
c: entity_content,
|
|
}
|
|
}
|
|
|
|
pub fn from_components(components: AddressComponents) -> Result<Self, UpEndError> {
|
|
// TODO: make this automatically derive from `Address` definition
|
|
let address = match components {
|
|
AddressComponents { t, c } if t == "Attribute" => Address::Attribute(
|
|
c.ok_or(UpEndError::AddressComponentsDecodeError(
|
|
AddressComponentsDecodeError::MissingValue,
|
|
))?
|
|
.parse()?,
|
|
),
|
|
AddressComponents { t, c } if t == "Url" => Address::Url(if let Some(string) = c {
|
|
Url::parse(&string).map_err(|e| {
|
|
UpEndError::AddressComponentsDecodeError(
|
|
AddressComponentsDecodeError::UrlDecodeError(e.to_string()),
|
|
)
|
|
})?
|
|
} else {
|
|
Err(UpEndError::AddressComponentsDecodeError(
|
|
AddressComponentsDecodeError::MissingValue,
|
|
))?
|
|
}),
|
|
AddressComponents { t, c } if t == "Uuid" => match c {
|
|
Some(c) => c.parse()?,
|
|
None => Address::Uuid(Uuid::new_v4()),
|
|
},
|
|
AddressComponents { t, .. } => Err(UpEndError::AddressComponentsDecodeError(
|
|
AddressComponentsDecodeError::UnknownType(t),
|
|
))?,
|
|
};
|
|
|
|
Ok(address)
|
|
}
|
|
}
|
|
|
|
impl Serialize for Address {
|
|
fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
serializer.serialize_str(b58_encode(self.encode().map_err(ser::Error::custom)?).as_str())
|
|
}
|
|
}
|
|
|
|
struct AddressVisitor;
|
|
|
|
impl<'de> Visitor<'de> for AddressVisitor {
|
|
type Value = Address;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
formatter.write_str("a valid UpEnd address (hash/UUID) as a multi-hashed string")
|
|
}
|
|
|
|
fn visit_str<E>(self, str: &str) -> Result<Self::Value, E>
|
|
where
|
|
E: de::Error,
|
|
{
|
|
let bytes = b58_decode(str)
|
|
.map_err(|e| de::Error::custom(format!("Error deserializing address: {}", e)))?;
|
|
Address::decode(bytes.as_ref())
|
|
.map_err(|e| de::Error::custom(format!("Error deserializing address: {}", e)))
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Address {
|
|
fn deserialize<D>(deserializer: D) -> Result<Address, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
deserializer.deserialize_str(AddressVisitor)
|
|
}
|
|
}
|
|
|
|
impl FromStr for Address {
|
|
type Err = UpEndError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
Address::decode(
|
|
b58_decode(s)
|
|
.map_err(|e| {
|
|
UpEndError::HashDecodeError(format!("Error deserializing address: {}", e))
|
|
})?
|
|
.as_ref(),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Address {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "{}", b58_encode(self.encode().map_err(|_| fmt::Error)?))
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Address {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(
|
|
f,
|
|
"Address<{}>: {}",
|
|
match self {
|
|
Address::Hash(_) => "Hash",
|
|
Address::Uuid(_) => "UUID",
|
|
Address::Attribute(_) => "Attribute",
|
|
Address::Url(_) => "URL",
|
|
},
|
|
self
|
|
)
|
|
}
|
|
}
|
|
|
|
pub trait Addressable: AsMultihash {
|
|
fn address(&self) -> Result<Address, AsMultihashError> {
|
|
Ok(Address::Hash(self.as_multihash()?))
|
|
}
|
|
}
|
|
|
|
impl<T> Addressable for T where T: AsMultihash {}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use url::Url;
|
|
use uuid::Uuid;
|
|
|
|
use crate::addressing::{Address, IDENTITY};
|
|
use crate::constants::{
|
|
TYPE_ATTRIBUTE_ADDRESS, TYPE_HASH_ADDRESS, TYPE_URL_ADDRESS, TYPE_UUID_ADDRESS,
|
|
};
|
|
use crate::hash::{LargeMultihash, UpMultihash};
|
|
|
|
use super::UpEndError;
|
|
|
|
#[test]
|
|
fn test_hash_codec() -> Result<(), UpEndError> {
|
|
let addr = Address::Hash(UpMultihash::from(
|
|
LargeMultihash::wrap(IDENTITY, &[1, 2, 3, 4, 5]).unwrap(),
|
|
));
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, decoded);
|
|
|
|
let addr = &*TYPE_HASH_ADDRESS;
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, &decoded);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_uuid_codec() -> Result<(), UpEndError> {
|
|
let addr = Address::Uuid(Uuid::new_v4());
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, decoded);
|
|
|
|
let addr = &*TYPE_UUID_ADDRESS;
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, &decoded);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_attribute_codec() -> Result<(), UpEndError> {
|
|
let addr = Address::Attribute("ATTRIBUTE".parse().unwrap());
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, decoded);
|
|
|
|
let addr = &*TYPE_ATTRIBUTE_ADDRESS;
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, &decoded);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_url_codec() -> Result<(), UpEndError> {
|
|
let addr = Address::Url(Url::parse("https://upend.dev/an/url/that/is/particularly/long/because/multihash/used/to/have/a/small/limit").unwrap());
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, decoded);
|
|
|
|
let addr = &*TYPE_URL_ADDRESS;
|
|
let encoded = addr.encode()?;
|
|
let decoded = Address::decode(&encoded)?;
|
|
assert_eq!(addr, &decoded);
|
|
Ok(())
|
|
}
|
|
}
|