use std::collections::BTreeMap;
use std::path::Path;
use muniment::{Backend, MemoryBackend, RedbBackend, StoreError};
use p2panda_core::{Hash, Operation, Topic, VerifyingKey};
use p2panda_store::logs::LogStore;
use p2panda_store::topics::TopicStore;
use stickleback::{
Admission, MunimentStore, OperationPolicy, OperationProcessor, ProcessError, Reject,
StoreTarget,
};
use crate::moot::tessera::event::TesseraEvent;
use crate::moot::tessera::ledger::{Ledger, TesseraConfig};
use crate::moot::tessera::wire::{TesseraExt, from_operation, to_operation_seed};
const LOG_ID: u64 = 0;
#[derive(Debug, thiserror::Error)]
pub enum TesseraStoreError {
#[error(transparent)]
Store(#[from] StoreError),
#[error(transparent)]
Process(#[from] ProcessError),
#[error("malformed tessera operation")]
Malformed,
}
#[derive(Clone, Copy)]
struct TesseraPolicy {
moot_id: [u8; 32],
}
impl OperationPolicy<TesseraExt> for TesseraPolicy {
type LogId = u64;
fn admit(&self, operation: &Operation<TesseraExt>) -> Result<Admission<Self::LogId>, Reject> {
if operation.header.extensions.moot_id != self.moot_id {
return Err(Reject::new(
"wrong-moot",
"operation addresses a different moot",
));
}
from_operation(operation).map_err(|_| {
Reject::new(
"invalid-tessera-event",
"operation body is not a Tessera event",
)
})?;
Ok(Admission::keep(StoreTarget::new(
Topic::from(self.moot_id),
LOG_ID,
)))
}
}
#[derive(Clone)]
pub struct TesseraStore<B> {
store: MunimentStore<B, TesseraExt>,
}
pub type TesseraFileStore = TesseraStore<RedbBackend>;
impl TesseraStore<MemoryBackend> {
pub fn in_memory() -> Self {
Self {
store: MunimentStore::new(MemoryBackend::new()),
}
}
}
impl TesseraStore<RedbBackend> {
pub fn open(path: impl AsRef<Path>) -> Result<Self, TesseraStoreError> {
Ok(Self {
store: MunimentStore::new(RedbBackend::open(path)?),
})
}
}
impl<B: Backend + Clone> TesseraStore<B> {
pub async fn author_seed(
&self,
signing_seed: [u8; 32],
moot_id: [u8; 32],
event: &TesseraEvent,
) -> Result<Operation<TesseraExt>, TesseraStoreError> {
let author = p2panda_core::SigningKey::from_bytes(&signing_seed).verifying_key();
let previous = self.store.get_latest_entry(&author, &LOG_ID).await?;
let (seq_num, backlink) = match previous {
Some(operation) => (
operation.header.seq_num + 1,
Some(*operation.hash.as_bytes()),
),
None => (0, None),
};
let operation = to_operation_seed(signing_seed, moot_id, event, seq_num, backlink);
self.accept(moot_id, &operation).await?;
Ok(operation)
}
pub fn sync_store(&self) -> MunimentStore<B, TesseraExt> {
self.store.clone()
}
}
impl<B: Backend + Clone> TesseraStore<B> {
pub async fn insert(&self, op: &Operation<TesseraExt>) -> Result<bool, TesseraStoreError> {
self.accept(op.header.extensions.moot_id, op).await
}
pub async fn accept(
&self,
moot_id: [u8; 32],
op: &Operation<TesseraExt>,
) -> Result<bool, TesseraStoreError> {
let processor = OperationProcessor::new(self.store.clone(), TesseraPolicy { moot_id });
Ok(processor.process(op).await?.inserted())
}
pub async fn get(
&self,
hash: &Hash,
) -> Result<Option<Operation<TesseraExt>>, TesseraStoreError> {
Ok(self.store.get_operation(hash).await?)
}
pub async fn has(&self, hash: &Hash) -> Result<bool, TesseraStoreError> {
Ok(self.store.has_operation(hash).await?)
}
pub async fn len(&self) -> Result<usize, TesseraStoreError> {
Ok(self.store.operation_count().await?)
}
pub async fn is_empty(&self) -> Result<bool, TesseraStoreError> {
Ok(self.store.is_empty().await?)
}
pub async fn fold_moot(
&self,
moot_id: [u8; 32],
config: TesseraConfig,
) -> Result<Ledger, TesseraStoreError> {
let logs: BTreeMap<VerifyingKey, Vec<u64>> =
self.store.resolve(&Topic::from(moot_id)).await?;
let mut tagged: Vec<(u64, [u8; 32], u64, TesseraEvent)> = Vec::new();
for (author, log_ids) in logs {
let author_bytes = *author.as_bytes();
for log_id in log_ids {
let Some(entries) = self
.store
.get_log_entries(&author, &log_id, None, None)
.await?
else {
continue;
};
for (op, _header) in entries {
let seq = op.header.seq_num;
let (_moot, event) =
from_operation(&op).map_err(|_| TesseraStoreError::Malformed)?;
tagged.push((event.at_ms(), author_bytes, u64::from(seq), event));
}
}
}
tagged.sort_by_key(|entry| (entry.0, entry.1, entry.2));
let mut ledger = Ledger::new(config);
for (_, _, _, event) in &tagged {
ledger.apply(event);
}
Ok(ledger)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::moot::tessera::event::{ChainRoot, CommitmentId, Scope};
use crate::moot::tessera::wire::to_operation;
use identity::{Ed25519Keypair, IdentityProvider, InMemoryProvider};
use tempfile::tempdir;
const MOOT: [u8; 32] = [0x30; 32];
fn keypair(seed: u8) -> Ed25519Keypair {
InMemoryProvider::from_seed([seed; 32])
.derive_keypair(b"tessera-store-test")
.unwrap()
}
fn root_of(kp: &Ed25519Keypair) -> ChainRoot {
ChainRoot(kp.public_key().to_bytes())
}
fn commit_fulfil_govern(kp: &Ed25519Keypair) -> [Operation<TesseraExt>; 3] {
let by = root_of(kp);
let cid = CommitmentId([0xc1; 32]);
let e0 = TesseraEvent::CommitmentMade {
by,
commitment: cid,
scope: Scope("host/cluster".into()),
cadence_ms: 1_000,
duration_ms: None,
at_ms: 1_000,
};
let e1 = TesseraEvent::CommitmentFulfilled {
by,
commitment: cid,
at_ms: 1_050,
};
let e2 = TesseraEvent::GovernanceParticipation { by, at_ms: 1_100 };
let op0 = to_operation(kp, MOOT, &e0, 0, None);
let op1 = to_operation(kp, MOOT, &e1, 1, Some(*op0.hash.as_bytes()));
let op2 = to_operation(kp, MOOT, &e2, 2, Some(*op1.hash.as_bytes()));
[op0, op1, op2]
}
#[tokio::test]
async fn insert_then_get_round_trips_and_is_idempotent() {
let store = TesseraStore::in_memory();
let [op0, op1, op2] = commit_fulfil_govern(&keypair(1));
assert!(store.insert(&op0).await.unwrap());
assert!(store.insert(&op1).await.unwrap());
assert!(store.insert(&op2).await.unwrap());
assert!(
!store.insert(&op2).await.unwrap(),
"re-insert is idempotent on the hash"
);
assert_eq!(store.len().await.unwrap(), 3);
let got = store.get(&op1.hash).await.unwrap().expect("op stored");
assert_eq!(got.hash, op1.hash);
assert!(store.has(&op0.hash).await.unwrap());
}
#[tokio::test]
async fn expected_moot_rejects_cross_space_replay_before_mutation() {
let store = TesseraStore::in_memory();
let kp = keypair(1);
let foreign = to_operation(
&kp,
[0xee; 32],
&TesseraEvent::GovernanceParticipation {
by: root_of(&kp),
at_ms: 1_000,
},
0,
None,
);
assert!(matches!(
store.accept(MOOT, &foreign).await,
Err(TesseraStoreError::Process(ProcessError::Rejected(Reject {
code: "wrong-moot",
..
})))
));
assert!(store.is_empty().await.unwrap());
}
#[tokio::test]
async fn fold_moot_projects_a_single_authors_score() {
let store = TesseraStore::in_memory();
let kp = keypair(1);
for op in commit_fulfil_govern(&kp) {
store.insert(&op).await.unwrap();
}
let ledger = store
.fold_moot(MOOT, TesseraConfig::default())
.await
.unwrap();
assert_eq!(ledger.score(&root_of(&kp), 5_000), 11);
}
#[tokio::test]
async fn fold_moot_merges_every_members_log() {
let store = TesseraStore::in_memory();
let alice = keypair(1);
let bob = keypair(2);
for op in commit_fulfil_govern(&alice) {
store.insert(&op).await.unwrap();
}
let bob_govern = TesseraEvent::GovernanceParticipation {
by: root_of(&bob),
at_ms: 1_200,
};
store
.insert(&to_operation(&bob, MOOT, &bob_govern, 0, None))
.await
.unwrap();
let ledger = store
.fold_moot(MOOT, TesseraConfig::default())
.await
.unwrap();
assert_eq!(ledger.score(&root_of(&alice), 5_000), 11);
assert_eq!(ledger.score(&root_of(&bob), 5_000), 1);
}
#[tokio::test]
async fn fold_moot_ignores_a_foreign_moot() {
let store = TesseraStore::in_memory();
let kp = keypair(1);
for op in commit_fulfil_govern(&kp) {
store.insert(&op).await.unwrap();
}
let ledger = store
.fold_moot([0xee; 32], TesseraConfig::default())
.await
.unwrap();
assert_eq!(ledger.score(&root_of(&kp), 5_000), 0);
}
#[tokio::test]
async fn operations_persist_across_reopen() {
let dir = tempdir().unwrap();
let path = dir.path().join("moot.redb");
let kp = keypair(1);
let ops = commit_fulfil_govern(&kp);
{
let store = TesseraStore::open(&path).unwrap();
for op in &ops {
store.insert(op).await.unwrap();
}
assert_eq!(store.len().await.unwrap(), 3);
}
let store = TesseraStore::open(&path).unwrap();
assert_eq!(store.len().await.unwrap(), 3);
let ledger = store
.fold_moot(MOOT, TesseraConfig::default())
.await
.unwrap();
assert_eq!(ledger.score(&root_of(&kp), 5_000), 11);
}
}