use std::collections::{HashMap, HashSet};
use crate::moot::tessera::event::{BASIS_POINTS, ChainRoot};
use crate::moot::tessera::ledger::Ledger;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct PersonaId(pub [u8; 32]);
#[derive(Clone, Debug, Default)]
pub struct PersonaChains {
parent: HashMap<PersonaId, PersonaId>,
}
impl PersonaChains {
pub fn new() -> Self {
Self::default()
}
pub fn fork(&mut self, child: PersonaId, parent: PersonaId) {
self.parent.insert(child, parent);
}
pub fn root_and_depth(&self, persona: PersonaId) -> (ChainRoot, u32) {
let mut current = persona;
let mut depth = 0u32;
let mut visited = HashSet::new();
visited.insert(current);
while let Some(&parent) = self.parent.get(¤t) {
if !visited.insert(parent) {
break; }
current = parent;
depth += 1;
}
(ChainRoot(current.0), depth)
}
pub fn root_of(&self, persona: PersonaId) -> ChainRoot {
self.root_and_depth(persona).0
}
pub fn effective_score(&self, persona: PersonaId, ledger: &Ledger, now_ms: u64) -> i64 {
let (root, depth) = self.root_and_depth(persona);
let base = ledger.score(&root, now_ms);
if base <= 0 {
return base; }
let factor = ledger.config().depreciation_bp as i64;
let mut score = base;
for _ in 0..depth {
score = score * factor / (BASIS_POINTS as i64);
}
score
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::moot::tessera::event::{CommitmentId, Scope, TesseraEvent};
use crate::moot::tessera::ledger::TesseraConfig;
fn persona(n: u8) -> PersonaId {
PersonaId([n; 32])
}
fn ledger_with_root_fulfilments(root: PersonaId, fulfilments: u8) -> Ledger {
let root = ChainRoot(root.0);
let mut events = Vec::new();
for i in 0..fulfilments {
let c = CommitmentId([100 + i; 32]);
events.push(TesseraEvent::CommitmentMade {
by: root,
commitment: c,
scope: Scope("s".into()),
cadence_ms: 100,
duration_ms: None,
at_ms: 0,
});
events.push(TesseraEvent::CommitmentFulfilled {
by: root,
commitment: c,
at_ms: 1,
});
}
Ledger::from_events(TesseraConfig::default(), &events)
}
#[test]
fn a_root_is_its_own_root_at_depth_zero() {
let chains = PersonaChains::new();
assert_eq!(chains.root_and_depth(persona(1)), (ChainRoot([1; 32]), 0));
}
#[test]
fn forks_resolve_to_the_root_at_increasing_depth() {
let mut chains = PersonaChains::new();
let (r, p1, p2) = (persona(1), persona(2), persona(3));
chains.fork(p1, r);
chains.fork(p2, p1);
assert_eq!(chains.root_and_depth(p1), (ChainRoot([1; 32]), 1));
assert_eq!(chains.root_and_depth(p2), (ChainRoot([1; 32]), 2));
assert_eq!(chains.root_of(p2), ChainRoot([1; 32]));
}
#[test]
fn the_root_presents_full_standing() {
let r = persona(1);
let ledger = ledger_with_root_fulfilments(r, 10); let chains = PersonaChains::new();
assert_eq!(chains.effective_score(r, &ledger, 10), 100);
}
#[test]
fn a_fork_inherits_the_depreciated_fraction() {
let r = persona(1);
let ledger = ledger_with_root_fulfilments(r, 10); let mut chains = PersonaChains::new();
let p1 = persona(2);
chains.fork(p1, r);
assert_eq!(chains.effective_score(p1, &ledger, 10), 50); }
#[test]
fn deeper_forks_depreciate_further() {
let r = persona(1);
let ledger = ledger_with_root_fulfilments(r, 10); let mut chains = PersonaChains::new();
let (p1, p2) = (persona(2), persona(3));
chains.fork(p1, r);
chains.fork(p2, p1);
assert_eq!(chains.effective_score(p2, &ledger, 10), 25); }
#[test]
fn a_fresh_chain_presents_zero() {
let ledger = Ledger::new(TesseraConfig::default());
let chains = PersonaChains::new();
assert_eq!(chains.effective_score(persona(9), &ledger, 10), 0);
}
#[test]
fn debt_carries_fully_to_forks_no_laundering() {
let r = persona(1);
let ledger = Ledger::from_events(
TesseraConfig::default(),
&[TesseraEvent::CommitmentMade {
by: ChainRoot([1; 32]),
commitment: CommitmentId([7; 32]),
scope: Scope("s".into()),
cadence_ms: 100,
duration_ms: None,
at_ms: 0,
}],
);
assert_eq!(ledger.score(&ChainRoot([1; 32]), 1_000), -20);
let mut chains = PersonaChains::new();
chains.fork(persona(2), r);
assert_eq!(chains.effective_score(persona(2), &ledger, 1_000), -20);
}
#[test]
fn a_cyclic_chain_terminates() {
let mut chains = PersonaChains::new();
let (a, b) = (persona(1), persona(2));
chains.fork(a, b);
chains.fork(b, a); let (_root, depth) = chains.root_and_depth(a);
assert!(depth <= 2, "cycle resolution stays finite");
}
}