use identity::Ed25519Keypair;
use p2panda_core::operation::validate_operation;
use p2panda_core::cbor::{decode_cbor, encode_cbor};
use p2panda_core::{Body, Hash, Header, Operation, SigningKey};
use serde::{Deserialize, Serialize};
use crate::moot::tessera::event::TesseraEvent;
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct TesseraExt {
pub moot_id: [u8; 32],
}
#[derive(Debug, PartialEq, Eq)]
pub enum WireError {
MissingBody,
Malformed,
}
pub fn to_operation(
keypair: &Ed25519Keypair,
moot_id: [u8; 32],
event: &TesseraEvent,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<TesseraExt> {
to_operation_seed(keypair.to_seed(), moot_id, event, seq_num, backlink)
}
pub fn to_operation_seed(
signing_seed: [u8; 32],
moot_id: [u8; 32],
event: &TesseraEvent,
seq_num: u32,
backlink: Option<[u8; 32]>,
) -> Operation<TesseraExt> {
let signing_key = SigningKey::from_bytes(&signing_seed);
let body_bytes = encode_cbor(event).expect("a TesseraEvent 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, TesseraExt { moot_id });
let hash = header.hash();
Operation {
hash,
header,
body: Some(body),
}
}
pub fn from_operation(op: &Operation<TesseraExt>) -> Result<([u8; 32], TesseraEvent), WireError> {
let body = op.body.as_ref().ok_or(WireError::MissingBody)?;
let event: TesseraEvent =
decode_cbor(body.to_bytes().as_slice()).map_err(|_| WireError::Malformed)?;
Ok((op.header.extensions.moot_id, event))
}
pub fn verify(operation: &Operation<TesseraExt>) -> bool {
validate_operation(operation).is_ok() && operation.hash == operation.header.hash()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::moot::tessera::event::{ChainRoot, CommitmentId, Scope};
use identity::{IdentityProvider, InMemoryProvider};
const MOOT: [u8; 32] = [0x30; 32];
fn keypair() -> Ed25519Keypair {
InMemoryProvider::from_seed([7; 32])
.derive_keypair(b"tessera-wire")
.unwrap()
}
fn sample_event(root: ChainRoot) -> TesseraEvent {
TesseraEvent::CommitmentMade {
by: root,
commitment: CommitmentId([1; 32]),
scope: Scope("cluster/a".into()),
cadence_ms: 1000,
duration_ms: None,
at_ms: 42,
}
}
#[test]
fn event_round_trips_through_an_operation() {
let kp = keypair();
let event = sample_event(ChainRoot(kp.public_key().to_bytes()));
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);
}
#[test]
fn a_signed_operation_verifies() {
let kp = keypair();
let op = to_operation(&kp, MOOT, &sample_event(ChainRoot([1; 32])), 0, None);
assert!(verify(&op));
}
#[test]
fn tampering_the_moot_id_breaks_verification() {
let kp = keypair();
let event = sample_event(ChainRoot([1; 32]));
let op = to_operation(&kp, MOOT, &event, 0, None);
let elsewhere = to_operation(&kp, [0xff; 32], &event, 0, None);
assert_ne!(op.header.encode(), elsewhere.header.encode());
let mut replayed = op.header.encode();
*replayed.last_mut().unwrap() ^= 0xff;
assert!(
Header::<TesseraExt>::decode(&replayed).is_err(),
"the moot id is signed, so a cross-moot replay fails"
);
}
#[test]
fn the_per_author_log_validates_under_p2panda() {
use p2panda_core::operation::{validate_backlink, validate_header};
let kp = keypair();
let op0 = to_operation(&kp, MOOT, &sample_event(ChainRoot([1; 32])), 0, None);
let e1 = TesseraEvent::GovernanceParticipation {
by: ChainRoot([1; 32]),
at_ms: 50,
};
let op1 = to_operation(&kp, MOOT, &e1, 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());
}
}