use crate::answer::Record;
use crate::canonical::jcs;
use crate::substrate::StatedCheckpoint;
use serde_json::{json, Map, Value};
use std::collections::BTreeMap;
use std::fmt;
pub const DERIVATION: &str = "standard_history/1";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StandardHistoryError(pub String);
impl fmt::Display for StandardHistoryError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "standard history: {}", self.0)
}
}
impl std::error::Error for StandardHistoryError {}
fn bad<T>(message: impl Into<String>) -> Result<T, StandardHistoryError> {
Err(StandardHistoryError(message.into()))
}
const MAX_COUNT: u64 = (1 << 53) - 1;
const COUNTERPARTY_CLASSES: [&str; 3] = ["person_agent", "business_agent", "shop_preauth"];
const NOT_COUNTED: &str = "shop_preauth";
const ROLES: [&str; 2] = ["provided", "bought"];
const OUTCOMES: [&str; 3] = ["held", "did_not_hold", "undecided"];
const HAPPENED: [&str; 3] = ["stamped_by_both", "receipt_only", "no_record"];
const SIDES: [&str; 2] = ["raised", "received"];
const DISPUTE_OUTCOMES: [&str; 6] = ["open", "for", "against", "split", "no_finding", "withdrawn"];
const FORUMS: [&str; 4] = ["auto", "network", "rail", "external"];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Window {
All,
Months(u64),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Policy {
pub digest: String,
pub window: Window,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AsOf {
pub anchor: String,
pub anchor_time: String,
pub first_checkpoint_time: String,
}
pub type Inputs = (Policy, Vec<Value>);
pub type InputsFn = Box<
dyn Fn(&StatedCheckpoint, &[HeldRecord]) -> Result<Inputs, StandardHistoryError> + Send + Sync,
>;
#[derive(Clone, Debug)]
pub struct HeldRecord {
pub record: Record,
pub header: Map<String, Value>,
}
pub struct StandardHistorySource {
pub holder_kind: String,
pub inputs: InputsFn,
}
impl StandardHistorySource {
pub fn validate(&self) -> Result<(), StandardHistoryError> {
controller_class(&self.holder_kind).map(|_| ())
}
}
pub fn controller_class(holder_kind: &str) -> Result<&'static str, StandardHistoryError> {
match holder_kind {
"person" => Ok("person_declared"),
"node" => Ok("node_declared"),
_ => bad(format!(
"holder kind {holder_kind:?} is neither person nor node"
)),
}
}
impl StandardHistorySource {
pub fn card(
&self,
anchor: &StatedCheckpoint,
first_checkpoint_time: &str,
records: &[HeldRecord],
) -> Result<Vec<u8>, StandardHistoryError> {
let (policy, deals) = (self.inputs)(anchor, records)?;
let as_of = AsOf {
anchor: crate::answer::anchor_digest(anchor),
anchor_time: crate::ask::profile_time(&anchor.checkpoint.timestamp),
first_checkpoint_time: crate::ask::profile_time(first_checkpoint_time),
};
derive_card(
&self.holder_kind,
controller_class(&self.holder_kind)?,
&as_of,
&policy,
&deals,
)
}
}
pub fn derive_card(
holder_kind: &str,
controller_class: &str,
as_of: &AsOf,
policy: &Policy,
deals: &[Value],
) -> Result<Vec<u8>, StandardHistoryError> {
if let Window::Months(n) = policy.window {
if !(1..=MAX_COUNT).contains(&n) {
return bad(format!("not a policy window: {n} months"));
}
}
let first = time(&as_of.first_checkpoint_time)?;
let anchor_time = time(&as_of.anchor_time)?;
let window = match policy.window {
Window::All => json!({"all": true}),
Window::Months(n) => json!({"months": n}),
};
let mut card = Map::new();
card.insert("derivation".into(), json!(DERIVATION));
card.insert("holder_kind".into(), json!(holder_kind));
card.insert("controller_class".into(), json!(controller_class));
card.insert("anchor".into(), json!(as_of.anchor));
card.insert("since".into(), json!(&first.text[..7]));
card.insert("window".into(), window);
card.insert("policy".into(), json!(policy.digest));
counts(deals, policy.window, &anchor_time, &mut card)?;
jcs(&Value::Object(card)).map_err(|e| StandardHistoryError(e.to_string()))
}
struct Time {
text: String,
year: i64,
month: i64,
day: i64,
}
fn time(text: &str) -> Result<Time, StandardHistoryError> {
let b = text.as_bytes();
let digits = |from: usize, to: usize| -> Option<i64> {
let part = b.get(from..to)?;
part.iter()
.all(u8::is_ascii_digit)
.then(|| part.iter().fold(0, |n, d| n * 10 + i64::from(d - b'0')))
};
let shape = b.len() == 20
&& [
(4, b'-'),
(7, b'-'),
(10, b'T'),
(13, b':'),
(16, b':'),
(19, b'Z'),
]
.iter()
.all(|&(i, c)| b[i] == c);
let parts = shape.then(|| {
Some((
digits(0, 4)?,
digits(5, 7)?,
digits(8, 10)?,
digits(11, 13)?,
digits(14, 16)?,
digits(17, 19)?,
))
});
let Some(Some((year, month, day, hour, minute, second))) = parts else {
return bad(format!("not an IP §5.2 time: {text:?}"));
};
if year < 1
|| !(1..=12).contains(&month)
|| day < 1
|| day > days_in_month(year, month)
|| hour > 23
|| minute > 59
|| second > 59
{
return bad(format!("not an IP §5.2 time: {text:?}"));
}
Ok(Time {
text: text.to_string(),
year,
month,
day,
})
}
fn days_in_month(year: i64, month: i64) -> i64 {
match month {
2 if year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) => 29,
2 => 28,
4 | 6 | 9 | 11 => 30,
_ => 31,
}
}
fn window_start(anchor: &Time, months: u64) -> Option<String> {
let total = i128::from(anchor.year) * 12 + i128::from(anchor.month - 1) - i128::from(months);
let (year, month) = (total.div_euclid(12), total.rem_euclid(12) + 1);
if year < 1 {
return None;
}
let (year, month) = (year as i64, month as i64);
let day = anchor.day.min(days_in_month(year, month));
Some(format!(
"{year:04}-{month:02}-{day:02}{}",
&anchor.text[10..]
))
}
fn in_window(agreed_at: &str, window: Window, anchor: &Time) -> bool {
if agreed_at > anchor.text.as_str() {
return false;
}
match window {
Window::All => true,
Window::Months(n) => {
window_start(anchor, n).is_none_or(|start| agreed_at >= start.as_str())
}
}
}
fn decade(amount: &Value) -> Result<Option<i64>, StandardHistoryError> {
let value = amount.get("value").and_then(Value::as_str);
let exact = value.is_some_and(|v| {
v == "0" || (!v.starts_with('0') && !v.is_empty() && v.bytes().all(|c| c.is_ascii_digit()))
});
let Some(value) = value.filter(|_| exact) else {
return bad(format!(
"amount value is not an exact integer string: {:?}",
amount.get("value")
));
};
let scale = amount.get("assetScale").and_then(Value::as_u64);
let Some(scale) = scale.filter(|s| *s <= 255) else {
return bad(format!(
"amount assetScale out of range: {:?}",
amount.get("assetScale")
));
};
Ok((value != "0").then(|| value.len() as i64 - scale as i64 - 1))
}
fn currency(code: &str) -> bool {
if code.len() == 3 && code.bytes().all(|c| c.is_ascii_uppercase()) {
return true;
}
let part = |s: &str, min: usize, max: usize, extra: &str| {
(min..=max).contains(&s.len())
&& s.bytes()
.all(|c| c.is_ascii_alphanumeric() || extra.as_bytes().contains(&c))
};
let lower = |s: &str| s.bytes().all(|c| !c.is_ascii_uppercase());
let Some((chain, asset)) = code.split_once('/') else {
return false;
};
let (Some((namespace, reference)), Some((asset_namespace, asset_reference))) =
(chain.split_once(':'), asset.split_once(':'))
else {
return false;
};
part(namespace, 3, 8, "-")
&& lower(namespace)
&& part(reference, 1, 32, "-_")
&& part(asset_namespace, 3, 8, "-")
&& lower(asset_namespace)
&& part(asset_reference, 1, 128, "-.%")
}
fn member<'a>(
deal: &'a Value,
name: &str,
allowed: &[&str],
) -> Result<&'a str, StandardHistoryError> {
match deal.get(name).and_then(Value::as_str) {
Some(v) if allowed.contains(&v) => Ok(v),
other => bad(format!(
"deal {}: {name} {other:?}",
deal.get("deal").and_then(Value::as_str).unwrap_or_default()
)),
}
}
fn check_entry(deal: &Value) -> Result<(), StandardHistoryError> {
if !deal.is_object() {
return bad("a deal entry is not an object");
}
let reference = match deal.get("deal").and_then(Value::as_str) {
Some(r) if !r.is_empty() => r,
_ => return bad("deal entry without a deal reference"),
};
time(
deal.get("agreed_at")
.and_then(Value::as_str)
.unwrap_or_default(),
)?;
if let Some(class) = deal.get("counterparty_class") {
if !class
.as_str()
.is_some_and(|c| COUNTERPARTY_CLASSES.contains(&c))
{
return bad(format!("unknown counterparty_class: {class}"));
}
}
member(deal, "role", &ROLES)?;
member(deal, "outcome", &OUTCOMES)?;
member(deal, "happened", &HAPPENED)?;
let amount = deal.get("amount");
let code = amount
.and_then(|a| a.get("assetCode"))
.and_then(Value::as_str);
if !code.is_some_and(currency) {
return bad(format!("deal {reference}: amount without an SR assetCode"));
}
decade(amount.expect("an amount with an assetCode is an object"))?;
let Some(disputes) = deal.get("disputes").and_then(Value::as_array) else {
return bad(format!("deal {reference}: disputes is not an array"));
};
for d in disputes {
let named = |name: &str, allowed: &[&str]| {
d.get(name)
.and_then(Value::as_str)
.is_some_and(|v| allowed.contains(&v))
};
if !(named("side", &SIDES)
&& named("outcome", &DISPUTE_OUTCOMES)
&& named("forum", &FORUMS))
{
return bad(format!("deal {reference}: malformed dispute {d}"));
}
}
Ok(())
}
#[derive(Clone)]
struct Tally(BTreeMap<&'static str, u64>);
impl Tally {
fn new(parts: &[&'static str]) -> Tally {
Tally(
std::iter::once("of")
.chain(parts.iter().copied())
.map(|p| (p, 0))
.collect(),
)
}
fn add(&mut self, part: &str) {
for (name, count) in self.0.iter_mut() {
if *name == part {
*count += 1;
}
}
}
fn value(&self) -> Value {
Value::Object(
self.0
.iter()
.map(|(k, v)| ((*k).to_string(), json!(v)))
.collect(),
)
}
}
fn counts(
deals: &[Value],
window: Window,
anchor: &Time,
card: &mut Map<String, Value>,
) -> Result<(), StandardHistoryError> {
let mut in_window_tally = Tally::new(&["counted", "not_counted"]);
let mut class_missing = Tally::new(&["count"]);
let mut outcomes = Tally::new(&OUTCOMES);
let mut roles = Tally::new(&ROLES);
let mut happened = Tally::new(&HAPPENED);
let mut bands: BTreeMap<(String, Option<i64>), Tally> = BTreeMap::new();
let mut disputes: BTreeMap<&str, (Tally, Tally, Tally)> = SIDES
.iter()
.map(|s| {
(
*s,
(
Tally::new(&[]),
Tally::new(&DISPUTE_OUTCOMES),
Tally::new(&FORUMS),
),
)
})
.collect();
for deal in deals {
check_entry(deal)?;
let agreed_at = deal["agreed_at"].as_str().unwrap_or_default();
if !in_window(agreed_at, window, anchor) {
continue;
}
in_window_tally.add("of");
let class = deal.get("counterparty_class").and_then(Value::as_str);
if class == Some(NOT_COUNTED) {
in_window_tally.add("not_counted");
continue;
}
in_window_tally.add("counted");
class_missing.add("of");
if class.is_none() {
class_missing.add("count");
}
for (tally, name) in [
(&mut outcomes, "outcome"),
(&mut roles, "role"),
(&mut happened, "happened"),
] {
tally.add("of");
tally.add(deal[name].as_str().unwrap_or_default());
}
let amount = &deal["amount"];
let key = (
amount["assetCode"].as_str().unwrap_or_default().to_string(),
decade(amount)?,
);
let band = bands.entry(key).or_insert_with(|| Tally::new(&OUTCOMES));
band.add("of");
band.add(deal["outcome"].as_str().unwrap_or_default());
for d in deal["disputes"].as_array().into_iter().flatten() {
let (of, by_outcome, by_forum) = disputes
.get_mut(d["side"].as_str().unwrap_or_default())
.expect("a checked side");
of.add("of");
by_outcome.add("of");
by_outcome.add(d["outcome"].as_str().unwrap_or_default());
by_forum.add("of");
by_forum.add(d["forum"].as_str().unwrap_or_default());
}
}
card.insert("in_window".into(), in_window_tally.value());
card.insert("class_missing".into(), class_missing.value());
card.insert("outcomes".into(), outcomes.value());
card.insert("roles".into(), roles.value());
card.insert("happened".into(), happened.value());
let bands: Vec<Value> = bands
.into_iter()
.map(|((code, decade), tally)| {
let Value::Object(mut band) = tally.value() else {
unreachable!("a tally is an object")
};
band.insert("currency".into(), json!(code));
band.insert("decade".into(), json!(decade));
Value::Object(band)
})
.collect();
card.insert("bands".into(), Value::Array(bands));
let disputes: Map<String, Value> = disputes
.into_iter()
.map(|(side, (of, by_outcome, by_forum))| {
(
side.to_string(),
json!({
"of": of.0["of"],
"by_outcome": by_outcome.value(),
"by_forum": by_forum.value(),
}),
)
})
.collect();
card.insert("disputes".into(), Value::Object(disputes));
Ok(())
}