use identity::Ed25519Keypair;
use p2panda_core::operation::validate_operation;
use p2panda_core::cbor::{decode_cbor, encode_cbor};
use p2panda_core::prune::PruneFlag;
use p2panda_core::{Body, Hash, Header, Operation, SigningKey};
use serde::{Deserialize, Serialize};
use super::retention::RetentionCheckpoint;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum MootLogId {
Events,
Checkpoints,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct MootExt {
pub moot_id: [u8; 32],
#[serde(
rename = "p",
skip_serializing_if = "PruneFlag::is_not_set",
default = "PruneFlag::default"
)]
pub prune_flag: PruneFlag,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum MootEvent {
Declared {
name: String,
charter: String,
at_ms: u64,
},
Joined { name: String, at_ms: u64 },
Shared {
manifest_id: [u8; 32],
schema_id: String,
title: String,
at_ms: u64,
},
RetentionCheckpoint {
checkpoint: Box<RetentionCheckpoint>,
},
HistoryPruned { checkpoint: [u8; 32], at_ms: u64 },
}
impl MootEvent {
pub(crate) fn log_id(&self) -> MootLogId {
match self {
Self::RetentionCheckpoint { .. } => MootLogId::Checkpoints,
_ => MootLogId::Events,
}
}
}
#[derive(Debug, PartialEq, Eq, thiserror::Error)]
pub enum WireError {
#[error("moot operation has no body")]
MissingBody,
#[error("moot operation body is not a MootEvent")]
Malformed,
}
pub fn to_operation(
keypair: &Ed25519Keypair,
moot_id: [u8; 32],
event: &MootEvent,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<MootExt> {
to_operation_seed(keypair.to_seed(), moot_id, event, seq_num, backlink)
}
pub fn to_prune_operation(
keypair: &Ed25519Keypair,
moot_id: [u8; 32],
checkpoint: [u8; 32],
at_ms: u64,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<MootExt> {
to_prune_operation_seed(
keypair.to_seed(),
moot_id,
checkpoint,
at_ms,
seq_num,
backlink,
)
}
pub fn to_prune_operation_seed(
signing_seed: [u8; 32],
moot_id: [u8; 32],
checkpoint: [u8; 32],
at_ms: u64,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<MootExt> {
to_operation_seed_with_prune(
signing_seed,
moot_id,
&MootEvent::HistoryPruned { checkpoint, at_ms },
seq_num,
backlink,
true,
)
}
pub fn to_operation_seed(
signing_seed: [u8; 32],
moot_id: [u8; 32],
event: &MootEvent,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<MootExt> {
to_operation_seed_with_prune(signing_seed, moot_id, event, seq_num, backlink, false)
}
fn to_operation_seed_with_prune(
signing_seed: [u8; 32],
moot_id: [u8; 32],
event: &MootEvent,
seq_num: u32,
backlink: Option<[u8; 32]>,
prune: bool,
) -> Operation<MootExt> {
let signing_key = SigningKey::from_bytes(&signing_seed);
let body_bytes = encode_cbor(event).expect("a MootEvent always CBOR-encodes");
let body = Body::from_bytes(&body_bytes);
let header = Header::builder()
.body(&body_bytes)
.seq_num(seq_num)
.backlink(backlink.map(Hash::from))
.build(&signing_key, MootExt {
moot_id,
prune_flag: PruneFlag::new(prune),
});
let hash = header.hash();
Operation {
hash,
header,
body: Some(body),
}
}
pub fn from_operation(op: &Operation<MootExt>) -> Result<([u8; 32], MootEvent), WireError> {
let body = op.body.as_ref().ok_or(WireError::MissingBody)?;
let event: MootEvent =
decode_cbor(body.to_bytes().as_slice()).map_err(|_| WireError::Malformed)?;
Ok((op.header.extensions.moot_id, event))
}
pub fn verify(operation: &Operation<MootExt>) -> bool {
validate_operation(operation).is_ok() && operation.hash == operation.header.hash()
}
#[cfg(test)]
mod tests {
use super::*;
use identity::{IdentityProvider, InMemoryProvider};
const MOOT: [u8; 32] = [0x6d; 32];
fn keypair(seed: u8) -> Ed25519Keypair {
InMemoryProvider::from_seed([seed; 32])
.derive_keypair(b"moot-wire")
.unwrap()
}
fn declared() -> MootEvent {
MootEvent::Declared {
name: "printing circle".to_string(),
charter: "we share what we set in type".to_string(),
at_ms: 42,
}
}
#[test]
fn an_event_round_trips_through_an_operation() {
let kp = keypair(7);
let event = declared();
let op = to_operation(&kp, MOOT, &event, 0, None);
let (moot_id, decoded) = from_operation(&op).expect("decode");
assert_eq!(moot_id, MOOT);
assert_eq!(decoded, event);
assert!(verify(&op));
}
#[test]
fn raw_seed_and_identity_keypair_produce_the_same_operation() {
let kp = keypair(8);
let event = declared();
assert_eq!(
to_operation(&kp, MOOT, &event, 0, None),
to_operation_seed(kp.to_seed(), MOOT, &event, 0, None)
);
}
#[test]
fn tampering_the_moot_id_breaks_verification() {
let kp = keypair(7);
let op = to_operation(&kp, MOOT, &declared(), 0, None);
let elsewhere = to_operation(&kp, [0xff; 32], &declared(), 0, None);
assert_ne!(op.header.encode(), elsewhere.header.encode());
let mut replayed = op.header.encode();
*replayed.last_mut().unwrap() ^= 0xff;
assert!(
Header::<MootExt>::decode(&replayed).is_err(),
"the moot id is signed; cross-moot replay fails"
);
}
#[test]
fn the_per_author_log_validates_under_p2panda() {
use p2panda_core::operation::{validate_backlink, validate_header};
let kp = keypair(7);
let op0 = to_operation(&kp, MOOT, &declared(), 0, None);
let join = MootEvent::Joined {
name: "mark".to_string(),
at_ms: 50,
};
let op1 = to_operation(&kp, MOOT, &join, 1, Some(*op0.hash.as_bytes()));
assert!(validate_header(&op0.header).is_ok());
assert!(validate_header(&op1.header).is_ok());
assert!(validate_backlink(&op0.header, &op1.header).is_ok());
}
}