use std::collections::HashMap;
pub use gemot::moot::MootId;
use gemot::tessera::event::BASIS_POINTS;
use gemot::tessera::ledger::Ledger;
use gemot::tessera::persona_chain::{PersonaChains, PersonaId};
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum CompositionPolicy {
Insular,
WeightedSum,
CautiousImport,
}
#[derive(Clone, Debug)]
pub struct RepLens {
moot: MootId,
composition: CompositionPolicy,
concords: HashMap<MootId, u16>,
}
impl RepLens {
pub fn new(moot: MootId, composition: CompositionPolicy) -> Self {
Self {
moot,
composition,
concords: HashMap::new(),
}
}
pub fn concord(&mut self, other: MootId, weight_bp: u16) -> &mut Self {
self.concords.insert(other, weight_bp);
self
}
pub fn weight(&self, other: &MootId) -> u16 {
self.concords.get(other).copied().unwrap_or(0)
}
pub fn composite_score(
&self,
persona: PersonaId,
ledgers: &HashMap<MootId, Ledger>,
chains: &PersonaChains,
now_ms: u64,
) -> i64 {
let effective = |moot: &MootId| -> i64 {
ledgers
.get(moot)
.map(|l| chains.effective_score(persona, l, now_ms))
.unwrap_or(0)
};
let local = effective(&self.moot);
if self.composition == CompositionPolicy::Insular {
return local;
}
let viewer_config = ledgers.get(&self.moot).map(|l| l.config());
let mut total = local;
for (other, &weight_bp) in &self.concords {
let schema_mismatch = matches!(
(viewer_config, ledgers.get(other).map(|l| l.config())),
(Some(a), Some(b)) if a != b
);
if schema_mismatch {
continue;
}
let remote = effective(other);
let weighted = remote * weight_bp as i64 / (BASIS_POINTS as i64);
total += match self.composition {
CompositionPolicy::Insular => 0, CompositionPolicy::WeightedSum => weighted,
CompositionPolicy::CautiousImport if remote < 0 => remote,
CompositionPolicy::CautiousImport => weighted,
};
}
total
}
}
#[cfg(test)]
mod tests {
use super::*;
use gemot::tessera::event::{ChainRoot, CommitmentId, Scope, TesseraEvent};
use gemot::tessera::ledger::TesseraConfig;
fn moot(n: u8) -> MootId {
MootId([n; 32])
}
fn persona(n: u8) -> PersonaId {
PersonaId([n; 32])
}
fn ledger_scoring(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)
}
fn ledger_in_debt(root: PersonaId) -> Ledger {
Ledger::from_events(
TesseraConfig::default(),
&[TesseraEvent::CommitmentMade {
by: ChainRoot(root.0),
commitment: CommitmentId([7; 32]),
scope: Scope("s".into()),
cadence_ms: 100,
duration_ms: None,
at_ms: 0,
}],
)
}
#[test]
fn insular_ignores_concords() {
let (v, x, p) = (moot(1), moot(2), persona(3));
let ledgers = HashMap::from([(v, ledger_scoring(p, 10)), (x, ledger_scoring(p, 10))]);
let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::Insular);
lens.concord(x, 10_000);
assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 100); }
#[test]
fn weighted_sum_imports_at_the_concord_weight() {
let (v, x, p) = (moot(1), moot(2), persona(3));
let ledgers = HashMap::from([(x, ledger_scoring(p, 10))]);
let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 5_000); assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 50);
}
#[test]
fn local_dominates_under_a_weak_concord() {
let (v, x, p) = (moot(1), moot(2), persona(3));
let ledgers = HashMap::from([(v, ledger_scoring(p, 10)), (x, ledger_scoring(p, 10))]);
let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 1_000); assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 110); }
#[test]
fn unconcorded_moots_do_not_count() {
let (v, z, p) = (moot(1), moot(9), persona(3));
let ledgers = HashMap::from([(z, ledger_scoring(p, 10))]);
let chains = PersonaChains::new();
let lens = RepLens::new(v, CompositionPolicy::WeightedSum);
assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 0);
}
#[test]
fn composition_is_one_hop_only() {
let (v, x, z, p) = (moot(1), moot(2), moot(9), persona(3));
let ledgers = HashMap::from([(z, ledger_scoring(p, 10))]); let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 10_000); assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 0);
}
#[test]
fn cautious_import_heeds_warnings_fully_discounts_praise() {
let (v, x, p) = (moot(1), moot(2), persona(3));
let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::CautiousImport);
lens.concord(x, 5_000);
let praised = HashMap::from([(x, ledger_scoring(p, 10))]);
assert_eq!(lens.composite_score(p, &praised, &chains, 10), 50);
let flagged = HashMap::from([(x, ledger_in_debt(p))]);
assert_eq!(lens.composite_score(p, &flagged, &chains, 1_000), -20);
}
#[test]
fn a_concorded_moots_contribution_is_the_depreciated_effective() {
let (v, x) = (moot(1), moot(2));
let r = persona(3);
let p1 = persona(4);
let ledgers = HashMap::from([(x, ledger_scoring(r, 10))]); let mut chains = PersonaChains::new();
chains.fork(p1, r); let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 10_000); assert_eq!(lens.composite_score(p1, &ledgers, &chains, 10), 50);
}
#[test]
fn a_pardon_in_one_moot_reaches_its_concorders() {
let (v, x) = (moot(1), moot(2));
let p = persona(3);
let gov = persona(50);
let chains = PersonaChains::new();
let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 5_000);
let unpardoned = HashMap::from([(x, ledger_in_debt(p))]);
assert_eq!(lens.composite_score(p, &unpardoned, &chains, 1_000), -10);
let pardoned = HashMap::from([(
x,
Ledger::from_events(
TesseraConfig::default(),
&[
TesseraEvent::CommitmentMade {
by: ChainRoot(p.0),
commitment: CommitmentId([7; 32]),
scope: Scope("s".into()),
cadence_ms: 100,
duration_ms: None,
at_ms: 0,
},
TesseraEvent::Pardon {
by: ChainRoot(gov.0),
target: ChainRoot(p.0),
weight: 20,
at_ms: 1,
},
],
),
)]);
assert_eq!(lens.composite_score(p, &pardoned, &chains, 1_000), 0);
}
#[test]
fn a_concord_across_mismatched_schemas_imports_nothing() {
let (v, x, p) = (moot(1), moot(2), persona(3));
let chains = PersonaChains::new();
let mut x_ledger = Ledger::new(TesseraConfig {
fulfil_reward: 99,
..TesseraConfig::default()
});
x_ledger.apply(&TesseraEvent::CommitmentMade {
by: ChainRoot(p.0),
commitment: CommitmentId([1; 32]),
scope: Scope("s".into()),
cadence_ms: 100,
duration_ms: None,
at_ms: 0,
});
x_ledger.apply(&TesseraEvent::CommitmentFulfilled {
by: ChainRoot(p.0),
commitment: CommitmentId([1; 32]),
at_ms: 1,
});
let ledgers = HashMap::from([(v, Ledger::new(TesseraConfig::default())), (x, x_ledger)]);
let mut lens = RepLens::new(v, CompositionPolicy::WeightedSum);
lens.concord(x, 10_000);
assert_eq!(lens.composite_score(p, &ledgers, &chains, 10), 0);
}
}