use super::{AuthorisationKind, CmdError, DataAuthKind, QueryResponse};
use crate::{Error, PublicKey, Result, Signature, XorName};
use serde::{Deserialize, Serialize};
use std::fmt;
pub const MAX_LOGIN_PACKET_BYTES: usize = 1024 * 1024;
#[allow(clippy::large_enum_variant)]
#[derive(Hash, Eq, PartialEq, PartialOrd, Clone, Serialize, Deserialize)]
pub enum AccountWrite {
New(Account),
Update(Account),
}
#[allow(clippy::large_enum_variant)]
#[derive(Hash, Eq, PartialEq, PartialOrd, Clone, Serialize, Deserialize)]
pub enum AccountRead {
Get(XorName),
}
impl AccountWrite {
pub fn error(&self, error: Error) -> CmdError {
use AccountWrite::*;
match *self {
New { .. } | Update { .. } => CmdError::Data(error),
}
}
pub fn authorisation_kind(&self) -> AuthorisationKind {
use AccountWrite::*;
match *self {
New { .. } | Update { .. } => AuthorisationKind::Data(DataAuthKind::Write),
}
}
pub fn dst_address(&self) -> XorName {
use AccountWrite::*;
match self {
New(account) => *account.address(),
Update(account) => *account.address(),
}
}
}
impl fmt::Debug for AccountWrite {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
use AccountWrite::*;
write!(
formatter,
"Request::{}",
match *self {
New { .. } => "NewAccount",
Update { .. } => "UpdateAccount",
}
)
}
}
impl AccountRead {
pub fn error(&self, error: Error) -> QueryResponse {
QueryResponse::GetAccount(Err(error))
}
pub fn authorisation_kind(&self) -> AuthorisationKind {
AuthorisationKind::Data(DataAuthKind::PrivateRead)
}
pub fn dst_address(&self) -> XorName {
use AccountRead::*;
match self {
Get(ref name) => *name,
}
}
}
impl fmt::Debug for AccountRead {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "Request::GetAccount")
}
}
#[derive(Debug, Hash, Eq, PartialEq, PartialOrd, Clone, Serialize, Deserialize)]
pub struct Account {
address: XorName,
owner: PublicKey, data: Vec<u8>,
signature: Signature,
}
impl Account {
pub fn new(
address: XorName,
owner: PublicKey,
data: Vec<u8>,
signature: Signature,
) -> Result<Self> {
let account = Self {
address,
owner,
data,
signature,
};
if account.size_is_valid() {
Ok(account)
} else {
Err(Error::ExceededSize)
}
}
pub fn size_is_valid(&self) -> bool {
self.data.len() <= MAX_LOGIN_PACKET_BYTES
}
pub fn address(&self) -> &XorName {
&self.address
}
pub fn owner(&self) -> &PublicKey {
&self.owner
}
pub fn data(&self) -> &[u8] {
&self.data
}
pub fn signature(&self) -> &Signature {
&self.signature
}
pub fn into_data_and_signature(self) -> (Vec<u8>, Signature) {
(self.data, self.signature)
}
}
#[cfg(test)]
mod tests {
use super::{Account, MAX_LOGIN_PACKET_BYTES};
use crate::{ClientFullId, Error};
#[test]
fn exceed_size_limit() {
let our_id = ClientFullId::new_ed25519(&mut rand::thread_rng());
let acc_data = vec![0; MAX_LOGIN_PACKET_BYTES + 1];
let signature = our_id.sign(&acc_data);
let res = Account::new(
rand::random(),
*our_id.public_id().public_key(),
acc_data,
signature,
);
match res {
Err(Error::ExceededSize) => (),
Ok(_) => panic!("Unexpected success"),
Err(e) => panic!("Unexpected error: {:?}", e),
}
}
#[test]
fn valid() {
let our_id = ClientFullId::new_ed25519(&mut rand::thread_rng());
let acc_data = vec![1; 16];
let signature = our_id.sign(&acc_data);
let res = Account::new(
rand::random(),
*our_id.public_id().public_key(),
acc_data.clone(),
signature,
);
match res {
Ok(ad) => {
assert_eq!(ad.data(), acc_data.as_slice());
}
Err(e) => panic!("Unexpected error: {:?}", e),
}
}
}