96 lines
2.0 KiB
Rust
96 lines
2.0 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use sha2::{Digest, Sha256};
|
|
use std::convert::{TryFrom, TryInto};
|
|
|
|
pub type GroupId = [u8; 16];
|
|
|
|
pub static ROOT_GROUP_ID: GroupId = [0; 16];
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct Group {
|
|
pub name: String,
|
|
pub parent: GroupId,
|
|
pub title: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize)]
|
|
pub struct AdId([u8; 16]);
|
|
|
|
impl AdId {
|
|
pub fn random() -> Self {
|
|
Self(rand::random())
|
|
}
|
|
}
|
|
|
|
impl AsRef<[u8]> for AdId {
|
|
fn as_ref(&self) -> &[u8] {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl TryFrom<&[u8]> for AdId {
|
|
type Error = std::array::TryFromSliceError;
|
|
|
|
fn try_from(v: &[u8]) -> Result<Self, Self::Error> {
|
|
Ok(Self(v.try_into()?))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
|
pub struct Ad {
|
|
pub author: String,
|
|
pub password: String,
|
|
pub price: String,
|
|
pub pubkey: Option<String>,
|
|
pub quantity: String,
|
|
pub time: u64,
|
|
pub title: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
pub struct AdWithId {
|
|
pub id: String,
|
|
pub ad: Ad,
|
|
pub selected: bool,
|
|
}
|
|
|
|
pub enum PubkeyDecodeError {
|
|
BadChecksum,
|
|
BadFormat,
|
|
}
|
|
|
|
/// Decode pubkey from base 58
|
|
/// Verify checksum if provided
|
|
/// Accepts any checksum length >=3
|
|
pub fn format_pubkey(raw: &str) -> Result<String, PubkeyDecodeError> {
|
|
let mut iter = raw.splitn(2, ':');
|
|
let raw_pubkey = iter.next().ok_or(PubkeyDecodeError::BadFormat)?;
|
|
if raw_pubkey.len() < 43 || raw_pubkey.len() > 44 {
|
|
return Err(PubkeyDecodeError::BadFormat);
|
|
}
|
|
let mut pubkey = [0u8; 32];
|
|
bs58::decode(raw_pubkey)
|
|
.into(&mut pubkey)
|
|
.map_err(|_| PubkeyDecodeError::BadFormat)?;
|
|
|
|
let mut hasher1 = Sha256::new();
|
|
hasher1.update(&pubkey.as_ref()[..32]);
|
|
let mut hasher2 = Sha256::new();
|
|
hasher2.update(hasher1.finalize());
|
|
let checksum = bs58::encode(hasher2.finalize()).into_string();
|
|
|
|
if let Some(given_checksum) = iter.next() {
|
|
if given_checksum.len() < 3 {
|
|
return Err(PubkeyDecodeError::BadFormat);
|
|
}
|
|
if !checksum.starts_with(given_checksum) {
|
|
return Err(PubkeyDecodeError::BadChecksum);
|
|
}
|
|
}
|
|
Ok(format!(
|
|
"{}:{}",
|
|
bs58::encode(pubkey).into_string(),
|
|
&checksum[..3]
|
|
))
|
|
}
|