use std::collections::VecDeque;
use std::io::Write;
use std::path::PathBuf;
use std::sync::Mutex;
use crossbeam_queue::SegQueue;
use dashmap::DashMap;
use serde::{Deserialize, Serialize};
pub const RETENTION_SECS: i64 = super::wal::EARN_DEDUPE_RETENTION.num_seconds();
pub const CAP: usize = 200_000;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Expected {
pub id: String,
pub cost: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub requester_fp: Option<String>,
pub ts: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub receipt_hash: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EarnClass {
Bound,
BoundByReceipt,
UnknownJob,
OverAmount,
WrongRequester,
}
impl EarnClass {
pub fn code(self) -> &'static str {
match self {
Self::Bound => "bound",
Self::BoundByReceipt => "bound_by_receipt",
Self::UnknownJob => "unknown_job",
Self::OverAmount => "over_amount",
Self::WrongRequester => "wrong_requester",
}
}
}
pub(super) fn epsilon(cost: f64) -> f64 {
1e-6 + cost.abs() * 1e-6
}
pub fn classify(expected: Option<&Expected>, amount: f64, signer_fp: Option<&str>) -> EarnClass {
let Some(e) = expected else {
return EarnClass::UnknownJob;
};
if amount > e.cost + epsilon(e.cost) {
return EarnClass::OverAmount;
}
if let (Some(want), Some(got)) = (e.requester_fp.as_deref(), signer_fp) {
if want != got {
return EarnClass::WrongRequester;
}
}
EarnClass::Bound
}
pub struct ExpectedEarns {
path: Option<PathBuf>,
map: DashMap<String, Expected>,
receipts: DashMap<String, String>,
order: Mutex<VecDeque<(String, i64)>>,
queue: SegQueue<String>,
cap: usize,
appended: std::sync::atomic::AtomicUsize,
file_lock: Mutex<()>,
}
impl ExpectedEarns {
pub fn in_memory() -> Self {
Self::with(None, CAP)
}
pub fn open(wal_path: &std::path::Path) -> Self {
let name = wal_path
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "wal".into());
Self::open_at(
wal_path.with_file_name(format!("{name}.earn-expected.jsonl")),
CAP,
)
}
fn open_at(path: PathBuf, cap: usize) -> Self {
let me = Self::with(Some(path.clone()), cap);
let bytes = std::fs::read(&path).unwrap_or_default();
if bytes.last().is_some_and(|b| *b != b'\n') {
let keep = bytes.iter().rposition(|b| *b == b'\n').map_or(0, |i| i + 1);
if let Ok(f) = std::fs::OpenOptions::new().write(true).open(&path) {
let _ = f.set_len(keep as u64);
}
}
let now = chrono::Utc::now().timestamp();
for l in String::from_utf8_lossy(&bytes).lines() {
if let Ok(e) = serde_json::from_str::<Expected>(l) {
me.insert(e, now);
}
}
me.appended.store(0, std::sync::atomic::Ordering::Relaxed);
me
}
fn with(path: Option<PathBuf>, cap: usize) -> Self {
Self {
path,
map: DashMap::new(),
receipts: DashMap::new(),
order: Mutex::new(VecDeque::new()),
queue: SegQueue::new(),
cap,
appended: std::sync::atomic::AtomicUsize::new(0),
file_lock: Mutex::new(()),
}
}
fn insert(&self, e: Expected, now: i64) {
let mut order = self.order.lock().unwrap_or_else(|p| p.into_inner());
if let Some(h) = &e.receipt_hash {
self.receipts.insert(h.clone(), e.id.clone());
}
self.map.insert(e.id.clone(), e.clone());
order.push_back((e.id.clone(), e.ts));
let cutoff = now - RETENTION_SECS;
while let Some((id, ts)) = order.front().cloned() {
if ts >= cutoff && order.len() <= self.cap {
break;
}
order.pop_front();
if let Some((_, gone)) = self.map.remove_if(&id, |_, v| v.ts == ts) {
if let Some(h) = gone.receipt_hash {
self.receipts.remove_if(&h, |_, rid| *rid == id);
}
}
}
}
pub fn record(&self, request_id: &str, cost: f64, requester_fp: Option<&str>) {
let now = chrono::Utc::now().timestamp();
let e = Expected {
id: request_id.to_string(),
cost,
requester_fp: requester_fp
.map(|f| super::node_identity::strip_node_arg(f).to_string())
.filter(|f| !f.is_empty()),
ts: now,
receipt_hash: None,
};
if let Ok(line) = serde_json::to_string(&e) {
self.queue.push(line);
}
self.insert(e, now);
}
pub fn bind_receipt(
&self,
request_id: &str,
receipt_hash: &str,
settled: f64,
requester_fp: Option<&str>,
) -> bool {
use dashmap::mapref::entry::Entry;
match self.receipts.entry(receipt_hash.to_string()) {
Entry::Occupied(o) if o.get() != request_id => return false,
Entry::Occupied(_) => {}
Entry::Vacant(v) => {
v.insert(request_id.to_string());
}
}
let now = chrono::Utc::now().timestamp();
let requester_fp = requester_fp
.map(|f| super::node_identity::strip_node_arg(f).to_string())
.filter(|f| !f.is_empty())
.or_else(|| self.get(request_id).and_then(|e| e.requester_fp));
let e = Expected {
id: request_id.to_string(),
cost: settled,
requester_fp,
ts: now,
receipt_hash: Some(receipt_hash.to_string()),
};
if let Ok(line) = serde_json::to_string(&e) {
self.queue.push(line);
}
self.insert(e, now);
true
}
pub fn receipt_backs(&self, receipt_hash: &str) -> Option<String> {
self.receipts.get(receipt_hash).map(|r| r.clone())
}
pub fn get(&self, request_id: &str) -> Option<Expected> {
self.map.get(request_id).map(|e| e.clone())
}
pub fn len(&self) -> usize {
self.map.len()
}
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
pub fn flush(&self) {
let Some(path) = &self.path else {
while self.queue.pop().is_some() {}
return;
};
let _io = self.file_lock.lock().unwrap_or_else(|e| e.into_inner());
let mut lines = Vec::new();
while let Some(l) = self.queue.pop() {
lines.push(l);
}
if !lines.is_empty() {
if let Some(dir) = path.parent() {
let _ = std::fs::create_dir_all(dir);
}
if let Ok(mut f) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)
{
let mut buf = lines.join("\n");
buf.push('\n');
if f.write_all(buf.as_bytes()).is_ok() {
let _ = f.sync_data();
self.appended
.fetch_add(lines.len(), std::sync::atomic::Ordering::Relaxed);
}
}
}
let live = self.map.len();
if self.appended.load(std::sync::atomic::Ordering::Relaxed) > live * 2 + 1024 {
let mut live_recs: Vec<Expected> = self.map.iter().map(|e| e.clone()).collect();
live_recs.sort_by_key(|e| e.ts);
let mut out = String::new();
for e in &live_recs {
if let Ok(l) = serde_json::to_string(e) {
out.push_str(&l);
out.push('\n');
}
}
let tmp = path.with_extension("tmp");
if std::fs::write(&tmp, out).is_ok() && std::fs::rename(&tmp, path).is_ok() {
self.appended.store(0, std::sync::atomic::Ordering::Relaxed);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn rec(cost: f64, fp: Option<&str>) -> Expected {
Expected {
id: "r".into(),
cost,
requester_fp: fp.map(String::from),
ts: 0,
receipt_hash: None,
}
}
#[test]
fn classification() {
assert_eq!(classify(None, 1.0, Some("a")), EarnClass::UnknownJob);
let e = rec(1.0, Some("aaaa"));
assert_eq!(classify(Some(&e), 0.9, Some("aaaa")), EarnClass::Bound);
assert_eq!(classify(Some(&e), 1.0, Some("aaaa")), EarnClass::Bound);
assert_eq!(
classify(Some(&e), 1.0000001, Some("aaaa")),
EarnClass::Bound
);
assert_eq!(classify(Some(&e), 1.5, Some("aaaa")), EarnClass::OverAmount);
assert_eq!(
classify(Some(&e), 0.5, Some("bbbb")),
EarnClass::WrongRequester
);
assert_eq!(classify(Some(&e), 0.5, None), EarnClass::Bound);
assert_eq!(
classify(Some(&rec(1.0, None)), 0.5, Some("bbbb")),
EarnClass::Bound
);
}
#[test]
fn records_are_bounded_by_count_and_replaced_by_id() {
let q = ExpectedEarns::with(None, 3);
for i in 0..5 {
q.record(&format!("r{i}"), 1.0, None);
}
assert_eq!(q.len(), 3);
assert!(q.get("r0").is_none() && q.get("r1").is_none());
assert!(q.get("r4").is_some());
q.record("r4", 2.0, Some("zc://node-abcd"));
let e = q.get("r4").unwrap();
assert_eq!((e.cost, e.requester_fp.as_deref()), (2.0, Some("abcd")));
}
#[test]
fn records_survive_a_restart_through_the_side_file_and_flush_is_the_only_io() {
let dir = std::env::temp_dir().join(format!("zc-ee-{}-{}", std::process::id(), line!()));
std::fs::create_dir_all(&dir).unwrap();
let wal = dir.join("wal.jsonl");
let q = ExpectedEarns::open(&wal);
q.record("job-1", 0.25, Some("ffff"));
let side = dir.join("wal.earn-expected.jsonl");
assert!(!side.exists(), "recording never touches the disk");
q.flush();
assert!(side.exists());
let q2 = ExpectedEarns::open(&wal);
let e = q2.get("job-1").expect("reloaded");
assert_eq!((e.cost, e.requester_fp.as_deref()), (0.25, Some("ffff")));
let mut s = std::fs::read_to_string(&side).unwrap();
s.push_str("{\"id\":\"torn");
std::fs::write(&side, s).unwrap();
let q3 = ExpectedEarns::open(&wal);
q3.record("job-2", 1.0, None);
q3.flush();
let q4 = ExpectedEarns::open(&wal);
assert!(q4.get("job-1").is_some() && q4.get("job-2").is_some());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_receipt_backs_one_earn_and_that_survives_a_restart() {
let dir = std::env::temp_dir().join(format!("zc-ee-{}-{}", std::process::id(), line!()));
std::fs::create_dir_all(&dir).unwrap();
let wal = dir.join("wal.jsonl");
let q = ExpectedEarns::open(&wal);
let h = "c".repeat(64);
assert!(q.bind_receipt("job-1", &h, 2.0, Some("zc://node-ffff")));
assert!(q.bind_receipt("job-1", &h, 2.0, None));
assert!(!q.bind_receipt("job-2", &h, 2.0, None));
assert_eq!(q.receipt_backs(&h).as_deref(), Some("job-1"));
let e = q.get("job-1").unwrap();
assert_eq!((e.cost, e.requester_fp.as_deref()), (2.0, Some("ffff")));
assert!(q.get("job-2").is_none(), "a refused bind records nothing");
q.flush();
let q2 = ExpectedEarns::open(&wal);
assert_eq!(q2.receipt_backs(&h).as_deref(), Some("job-1"));
assert!(!q2.bind_receipt("job-3", &h, 2.0, None));
assert_eq!(
q2.get("job-1").unwrap().receipt_hash.as_deref(),
Some(h.as_str())
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn an_evicted_record_frees_its_receipt() {
let q = ExpectedEarns::with(None, 2);
let (a, b) = ("a".repeat(64), "b".repeat(64));
assert!(q.bind_receipt("r0", &a, 1.0, None));
q.record("r1", 1.0, None);
q.record("r2", 1.0, None); assert!(q.get("r0").is_none());
assert_eq!(q.receipt_backs(&a), None);
assert!(q.bind_receipt("r9", &a, 1.0, None));
assert!(q.bind_receipt("r10", &b, 1.0, None));
}
}