use std::collections::HashMap;
use std::sync::Mutex;
use serde_json::Value;
use super::book::verify_book;
use super::check::record_digest;
use super::names::*;
use super::record::{decode, Body, Record};
use super::sent::verify_sent;
use super::types::*;
use crate::shelf::{
ReceiveProfile as ShelfReceiveProfile, ReceivedRecord, Shelf, ShelfBook, ShelfError, WeakShelf,
};
pub const SENT_LOG_PREFIX: &str = "x-deal-v1/sent/";
pub const GATE_NO_PROOF: &str = "no_counterparty_proof";
pub const GATE_NO_LAYER: &str = "counterparty_no_layer";
enum Read {
Book(super::book::BookRead),
Sent(super::sent::Sent),
}
impl Read {
fn record(&self) -> &Record {
match self {
Read::Book(b) => &b.record,
Read::Sent(s) => &s.record,
}
}
}
fn read_pair(record: &[u8]) -> Result<Read, String> {
let members: Value = serde_json::from_slice(record).map_err(|e| format!("not a pair: {e}"))?;
let Some(members) = members.as_object() else {
return Err("not a pair: not a JSON object".into());
};
if members.contains_key("agent_input") {
return verify_sent(record, None)
.map(Read::Sent)
.map_err(|e| e.to_string());
}
verify_book(record)
.map(Read::Book)
.map_err(|e| e.to_string())
}
struct Ours {
journal: Vec<Record>,
agreements: Vec<Record>,
}
impl Ours {
fn offer_by_digest(&self, d: &str) -> Option<(&ProposeBody, &Record)> {
self.journal.iter().find_map(|r| {
let b = r.propose()?;
(record_digest(r).ok()? == d).then_some((b, r))
})
}
fn agreement_record(&self, deal_id: &str) -> Option<&Record> {
self.agreements.iter().find(|r| {
r.agree().is_some_and(|a| a.kind == KIND_AGREEMENT) && r.block.deal_id == deal_id
})
}
fn agreement(&self, deal_id: &str) -> Option<&AgreeBody> {
self.agreements
.iter()
.filter(|r| r.block.deal_id == deal_id)
.find_map(Record::agree)
}
}
pub(super) enum Payload {
V1(Box<Record>),
Other,
Unavailable,
}
const TYPED_VERSION_TYPES: &[&str] = &[
crate::deal::TYPE_TASK_AUTHORITY,
crate::deal::TYPE_PROPOSED_ACTION,
crate::deal::TYPE_ACTION_EVALUATION,
crate::deal::TYPE_ACTION_APPROVAL,
crate::deal::TYPE_ACTION_RECORD,
crate::deal::TYPE_ACTION_OUTCOME,
crate::deal::TYPE_ACTION_REPORT,
crate::deal::TYPE_CHECK_REQUEST,
crate::deal::TYPE_CHECK_RESPONSE,
crate::deal::TYPE_COMMERCIAL_BOUNDS,
];
fn is_v1(raw: &[u8]) -> bool {
let Ok(Value::Object(top)) = serde_json::from_slice::<Value>(raw) else {
return false;
};
let versioned = |k: &&String| {
k.strip_prefix("x-deal-v")
.is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()))
};
let mut names = top.keys().filter(versioned);
let (Some(only), None) = (names.next(), names.next()) else {
return false;
};
let typed = top
.get("type")
.and_then(Value::as_str)
.is_some_and(|t| TYPED_VERSION_TYPES.contains(&t));
let profile = match &top[only] {
Value::Object(block) => block
.iter()
.filter(|(k, _)| k.eq_ignore_ascii_case("profile"))
.filter_map(|(_, v)| v.as_str())
.next_back(),
_ => None,
};
only == PROFILE && !typed && profile == Some(PROFILE)
}
pub(super) fn v1_payload(
book: &ShelfBook,
r: &crate::shelf::BookRecord,
) -> Result<Payload, ShelfError> {
let commitments = r
.header
.get("payload_commitments")
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
let [digest] = commitments.as_slice() else {
return Ok(Payload::Other);
};
let raw = match book.resolve_payload(&r.record_id, digest.as_str().unwrap_or("")) {
Ok(raw) => raw,
Err(ShelfError::Unavailable(_)) => return Ok(Payload::Unavailable),
Err(ShelfError::NotFound(_)) => return Ok(Payload::Other),
Err(e) => return Err(e),
};
if !is_v1(&raw) {
return Ok(Payload::Other);
}
Ok(decode(&raw).map_or(Payload::Other, |r| Payload::V1(Box::new(r))))
}
#[derive(Default)]
struct Cache {
journal_seen: u64,
journal: Vec<(u64, Record)>,
retry: Vec<u64>,
firsts: HashMap<String, Option<Record>>,
}
#[derive(Default)]
struct State {
last: Option<(String, Record)>,
cache: Cache,
}
#[derive(Default)]
pub struct ReceiveProfile {
shelf: Mutex<Option<WeakShelf>>,
state: Mutex<State>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct CanActInput {
pub deal_id: String,
pub counterpart_agreement: String,
pub commitment_shelf_log: String,
}
#[derive(Clone, Debug, PartialEq)]
pub struct ActGateInput {
pub own: Vec<Record>,
pub act: Record,
pub counterpart_agreement: String,
pub commitment_shelf_log: String,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize)]
pub struct ActGate {
pub gated: bool,
pub allowed: bool,
#[serde(skip_serializing_if = "std::ops::Not::not")]
pub unguarded: bool,
#[serde(skip_serializing_if = "String::is_empty")]
pub reason: String,
}
fn invalid(m: impl Into<String>) -> ShelfError {
ShelfError::Invalid(m.into())
}
impl ReceiveProfile {
pub fn new() -> Self {
Self::default()
}
pub fn set_shelf(&self, shelf: &Shelf) {
*self.shelf.lock().unwrap_or_else(|p| p.into_inner()) = Some(shelf.downgrade());
}
fn shelf(&self) -> Result<Shelf, ShelfError> {
self.shelf
.lock()
.unwrap_or_else(|p| p.into_inner())
.as_ref()
.and_then(WeakShelf::upgrade)
.ok_or_else(|| invalid("xdealv1: the receive profile has no shelf"))
}
fn ours(&self) -> Result<Ours, ShelfError> {
let shelf = self.shelf()?;
let mut state = self.state.lock().unwrap_or_else(|p| p.into_inner());
let c = &mut state.cache;
let journal = shelf.journal()?;
let size = journal.size();
let mut seqs = c.retry.clone();
seqs.extend(c.journal_seen + 1..=size);
let (mut added, mut retry) = (Vec::new(), Vec::new());
for &n in &seqs {
let Some(r) = journal.record_by_seq(n) else {
continue;
};
match v1_payload(&journal, &r)? {
Payload::V1(rec) => added.push((n, *rec)),
Payload::Unavailable => retry.push(n),
Payload::Other => {}
}
}
if !seqs.is_empty() {
for (n, rec) in added {
let at = c.journal.partition_point(|(seq, _)| *seq < n);
c.journal.insert(at, (n, rec));
}
c.journal_seen = size;
c.retry = retry;
}
let mut o = Ours {
journal: c.journal.iter().map(|(_, r)| r.clone()).collect(),
agreements: Vec::new(),
};
for log_id in shelf.books()? {
let first = match c.firsts.get(&log_id) {
Some(first) => first.clone(),
None => {
let book = shelf.open(&log_id)?;
let (mut first, mut unavailable) = (None, false);
if let Some(r) = book.record_by_seq(1) {
match v1_payload(&book, &r)? {
Payload::V1(rec)
if rec.agree().is_some_and(|a| a.kind == KIND_AGREEMENT) =>
{
first = Some(*rec)
}
Payload::Unavailable => unavailable = true,
_ => {}
}
}
if !unavailable {
c.firsts.insert(log_id.clone(), first.clone());
}
first
}
};
if let Some(first) = first {
o.agreements.push(first);
}
}
Ok(o)
}
fn held_sent(
&self,
shelf: &Shelf,
digest: &str,
) -> Result<Option<(Record, String)>, ShelfError> {
for h in shelf.held_first(&format!("{SENT_LOG_PREFIX}{digest}"))? {
if let Ok(s) = verify_sent(&h.record, None) {
if s.digest == digest {
return Ok(Some((s.record, h.received.sender_key)));
}
}
}
Ok(None)
}
fn held_genesis(
&self,
shelf: &Shelf,
sender_key: &str,
log_id: &str,
) -> Result<Option<Record>, ShelfError> {
let mut out = None;
for h in shelf.held_first(log_id)? {
if h.received.sender_key != sender_key {
continue;
}
if out.is_some() {
return Ok(None);
}
match verify_book(&h.record) {
Ok(b) => out = Some(b.record),
Err(_) => return Ok(None),
}
}
Ok(out)
}
fn held_or_pending(
&self,
shelf: &Shelf,
r: &ReceivedRecord,
) -> Result<Option<Record>, ShelfError> {
let last = self
.state
.lock()
.unwrap_or_else(|p| p.into_inner())
.last
.clone();
if let Some((digest, rec)) = last {
if digest == r.digest {
return Ok(Some(rec));
}
}
let h = match shelf.received_record_of(&r.digest) {
Ok(h) => h,
Err(ShelfError::NotFound(_) | ShelfError::Deleted(_)) => return Ok(None),
Err(e) => return Err(e),
};
Ok(read_pair(&h.record).ok().map(|rd| rd.record().clone()))
}
fn admit_record(&self, r: &ReceivedRecord) -> Result<bool, ShelfError> {
if r.offer {
return Ok(true);
}
let shelf = self.shelf()?;
let Some(rec) = self.held_or_pending(&shelf, r)? else {
return Ok(false);
};
let o = self.ours()?;
if r.log_id.starts_with(SENT_LOG_PREFIX) {
let Some(ag) = rec.agree() else {
return Ok(false);
};
if ag.kind == KIND_DECLINE {
return Ok(o
.offer_by_digest(&ag.offer.digest)
.is_some_and(|(of, offer)| {
offer.block.deal_id == rec.block.deal_id
&& of.to.value() == Some(&r.sender_key)
}));
}
if ag.kind == KIND_CANCELLATION {
return Ok(self.held_sent(&shelf, &ag.offer.digest)?.is_some_and(
|(offer, signer)| {
signer == r.sender_key
&& offer.block.record_type == TYPE_PROPOSE
&& offer.block.deal_id == rec.block.deal_id
},
));
}
return Ok(false);
}
if rec.block.record_type == TYPE_RULING {
return Ok(o
.agreement(&rec.block.deal_id)
.and_then(|a| a.adjudicator.value())
.is_some_and(|adj| adj.key_id == r.sender_key));
}
let genesis = if r.position > 1 {
match self.held_genesis(&shelf, &r.sender_key, &r.log_id)? {
Some(g) => g,
None => return Ok(false),
}
} else {
rec
};
let Some(gag) = genesis
.agree()
.filter(|g| g.kind == KIND_AGREEMENT && genesis.block.deal_id == r.deal_id)
else {
return Ok(false);
};
if let Some(a) = o.agreement(&r.deal_id) {
return Ok(a.counterparty_key.value() == Some(&r.sender_key)
&& gag.offer.digest == a.offer.digest);
}
Ok(o.offer_by_digest(&gag.offer.digest)
.is_some_and(|(of, offer)| {
offer.block.deal_id == r.deal_id && of.to.value() == Some(&r.sender_key)
}))
}
fn answered_offer(&self, offer: &ReceivedRecord) -> Result<bool, ShelfError> {
let shelf = self.shelf()?;
let h = shelf.received_record_of(&offer.digest)?;
let Ok(s) = verify_sent(&h.record, None) else {
return Ok(false);
};
let o = self.ours()?;
if o.agreements
.iter()
.filter_map(Record::agree)
.any(|a| a.offer.digest == s.digest)
{
return Ok(true);
}
Ok(o.journal.iter().any(|r| match &r.body {
Body::Agree(a) => a.kind == KIND_DECLINE && a.offer.digest == s.digest,
Body::Propose(b) => b.counter_to.as_ref().is_some_and(|c| c.digest == s.digest),
_ => false,
}))
}
fn proof_sender_of(
&self,
checkpoint_key_id: &str,
log_id: &str,
) -> Result<Option<String>, ShelfError> {
let shelf = self.shelf()?;
let held = shelf.held_first(log_id)?;
let mut first: HashMap<&str, &str> = HashMap::new();
let mut forked: Vec<&str> = Vec::new();
for h in &held {
let key = h.received.sender_key.as_str();
if first.get(key).is_some_and(|d| *d != h.received.digest) {
forked.push(key);
}
first.insert(key, h.received.digest.as_str());
}
let o = self.ours()?;
let mut candidates: Vec<String> = Vec::new();
for h in &held {
let key = &h.received.sender_key;
if forked.contains(&key.as_str()) || candidates.contains(key) {
continue;
}
let Ok(b) = verify_book(&h.record) else {
continue;
};
let Some(ag) = b
.record
.agree()
.filter(|a| a.kind == KIND_AGREEMENT && a.checkpoint_key == checkpoint_key_id)
else {
continue;
};
let deal = &b.record.block.deal_id;
let expected = match o.agreement(deal).and_then(|a| a.counterparty_key.value()) {
Some(k) => Some(k.clone()),
None => o
.offer_by_digest(&ag.offer.digest)
.filter(|(_, offer)| offer.block.deal_id == *deal)
.and_then(|(of, _)| of.to.value().cloned()),
};
if expected.as_ref() == Some(key) {
candidates.push(key.clone());
}
}
Ok(match candidates.as_slice() {
[one] => Some(one.clone()),
_ => None,
})
}
pub fn can_act(&self, input: &CanActInput) -> Result<bool, ShelfError> {
let shelf = self.shelf()?;
let h = match shelf.received_record_of(&input.counterpart_agreement) {
Ok(h) => h,
Err(ShelfError::NotFound(_) | ShelfError::Deleted(_)) => return Ok(false),
Err(e) => return Err(e),
};
let Ok(b) = verify_book(&h.record) else {
return Ok(false);
};
if h.received.position != 1 {
return Ok(false);
}
let Some(ag) = b
.record
.agree()
.filter(|a| a.kind == KIND_AGREEMENT && b.record.block.deal_id == input.deal_id)
else {
return Ok(false);
};
let sender = &h.received.sender_key;
let o = self.ours()?;
let expected = match o.agreement(&input.deal_id) {
Some(a) => {
a.counterparty_key.value() == Some(sender) && ag.offer.digest == a.offer.digest
}
None => o
.offer_by_digest(&ag.offer.digest)
.is_some_and(|(of, offer)| {
offer.block.deal_id == input.deal_id && of.to.value() == Some(sender)
}),
};
if !expected
|| (!input.commitment_shelf_log.is_empty()
&& input.commitment_shelf_log != ag.shelf_log_id)
{
return Ok(false);
}
let log_id = &h.received.log_id;
if shelf.counted_prefix(sender, log_id)?.size < 1 {
return Ok(false);
}
super::shelf_status::proof_covers(&shelf, sender, log_id, &input.counterpart_agreement, ag)
}
pub fn gate_act(&self, input: &ActGateInput) -> Result<ActGate, ShelfError> {
let Some(head) = input.own.first() else {
return Err(invalid("xdealv1: gate: the holder's book is empty"));
};
let Some(ag) = head.agree().filter(|a| a.kind == KIND_AGREEMENT) else {
return Err(invalid(
"xdealv1: gate: the holder's book does not open with its agreement",
));
};
let deal = &head.block.deal_id;
let o = self.ours()?;
let Some(mine) = o.agreement_record(deal) else {
return Err(invalid(format!(
"xdealv1: gate: the holder has sealed no agreement of deal {deal:?}"
)));
};
let digest = |r: &Record| record_digest(r).map_err(|e| invalid(e.to_string()));
if digest(head)? != digest(mine)? {
return Err(invalid(format!(
"xdealv1: gate: the book does not open with the holder's own agreement of deal {deal:?}"
)));
}
if input.act.block.deal_id != *deal {
return Err(invalid(format!(
"xdealv1: gate: the act is of deal {:?}, the book of {deal:?}",
input.act.block.deal_id
)));
}
let mut acted = false;
for r in &input.own[1..] {
if r.block.deal_id != *deal {
return Err(invalid(format!(
"xdealv1: gate: a record of deal {:?} in the book of {deal:?}",
r.block.deal_id
)));
}
acted = acted || gated_act(r);
}
if !gated_act(&input.act) || acted {
return Ok(ActGate {
allowed: true,
..Default::default()
});
}
if ag.counterparty_layer != Some(true) {
return Ok(ActGate {
gated: true,
allowed: true,
unguarded: true,
reason: GATE_NO_LAYER.into(),
});
}
let covered = self.can_act(&CanActInput {
deal_id: deal.clone(),
counterpart_agreement: input.counterpart_agreement.clone(),
commitment_shelf_log: input.commitment_shelf_log.clone(),
})?;
Ok(if covered {
ActGate {
gated: true,
allowed: true,
..Default::default()
}
} else {
ActGate {
gated: true,
reason: GATE_NO_PROOF.into(),
..Default::default()
}
})
}
}
fn gated_act(r: &Record) -> bool {
match &r.body {
Body::Perform(_) => true,
Body::Settle(s) => s.leg == LEG_PAYER,
_ => false,
}
}
fn profile_err(e: ShelfError) -> String {
e.to_string()
}
impl ShelfReceiveProfile for ReceiveProfile {
fn read(&self, record: &[u8]) -> Result<ReceivedRecord, String> {
let rd = read_pair(record)?;
let digest = match &rd {
Read::Book(b) => b.record_id.clone(),
Read::Sent(s) => s.capsule_id.clone(),
};
self.state.lock().unwrap_or_else(|p| p.into_inner()).last =
Some((digest, rd.record().clone()));
Ok(match rd {
Read::Book(b) => ReceivedRecord {
digest: b.record_id,
sender_key: b.key_id,
log_id: b.log_id,
position: b.seq,
prev: b.prev,
deal_id: b.record.block.deal_id,
offer: false,
},
Read::Sent(s) => ReceivedRecord {
digest: s.capsule_id,
sender_key: s.key_id,
log_id: format!("{SENT_LOG_PREFIX}{}", s.digest),
position: 1,
prev: String::new(),
offer: s.record.block.record_type == TYPE_PROPOSE,
deal_id: s.record.block.deal_id,
},
})
}
fn admit(&self, record: &ReceivedRecord) -> Result<bool, String> {
self.admit_record(record).map_err(profile_err)
}
fn answered(&self, offer: &ReceivedRecord) -> Result<bool, String> {
self.answered_offer(offer).map_err(profile_err)
}
fn proof_sender(
&self,
checkpoint_key_id: &str,
log_id: &str,
) -> Result<Option<String>, String> {
self.proof_sender_of(checkpoint_key_id, log_id)
.map_err(profile_err)
}
fn after_receive(
&self,
result: &crate::shelf::ReceiveResult,
at: crate::shelf::Time,
) -> Result<(), String> {
let mut deals = result.changes.grew.clone();
if let Some(r) = &result.record {
if r.refused.is_none()
&& (r.stored || r.duplicate)
&& !r.deal_id.is_empty()
&& !deals.contains(&r.deal_id)
{
deals.push(r.deal_id.clone());
}
}
let shelf = self.shelf().map_err(profile_err)?;
super::shelf_status::name_rulings(&shelf, &deals, at)
.map(drop)
.map_err(|e| profile_err(e.error))
}
}