use std::collections::{BTreeMap, HashMap, HashSet};
use agent_action_capsule::settlement::{verify_settlements, SettlementOptions};
use serde_json::{Map, Value};
use super::book::{verify_book, BookRead};
use super::check::{ref_to, stage_err};
use super::names::*;
use super::record::Body;
use super::sent::{is_payment_row, payment_rows, verify_sent, SETTLEMENT_MEMBER};
use super::status_value::PaymentResult;
use crate::deal::{Error, Ref};
pub const STAGE_PAYMENT: &str = "payment";
pub const PAYMENT_PASS: &str = "pass";
pub const PAYMENT_FAIL: &str = "fail";
pub const REASON_SEVERAL_PAYMENTS: &str = "several_payments";
pub const REASON_REFUND_CITES_OFFER: &str = "refund_cites_offer";
pub const REASON_NOT_AGREED: &str = "not_agreed";
pub const REASON_UNJOINED: &str = "unjoined";
pub const REASON_PENDING: &str = "pending";
pub const REASON_MISMATCH: &str = "mismatch";
pub const REASON_STATUS: &str = "status";
pub const REASON_AMOUNT: &str = "amount";
fn bad(m: impl Into<String>) -> Error {
stage_err(STAGE_PAYMENT, m.into())
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct PaymentInput {
pub offer: Vec<u8>,
pub offer_digest: String,
pub acceptor_key: String,
pub row: String,
pub legs: Vec<Vec<u8>>,
}
fn settlement_role(party: &str, owed_by: &str) -> &'static str {
if party == owed_by {
"payer"
} else {
"payee"
}
}
fn record_of(pair: &[u8]) -> Result<Map<String, Value>, Error> {
let p: Value = serde_json::from_slice(pair)?;
Ok(p.get("record")
.and_then(Value::as_object)
.cloned()
.unwrap_or_default())
}
pub fn payment_check(input: &PaymentInput) -> Result<PaymentResult, Error> {
let sent = verify_sent(&input.offer, None)?;
if sent.digest != input.offer_digest {
return Err(bad(format!(
"the offer given is not the started deal's offer {}",
input.offer_digest
)));
}
let Some(of) = sent.record.propose() else {
return Err(bad(format!(
"the offer given is a {}",
sent.record.block.record_type
)));
};
if of.to.value().is_some_and(|to| *to != input.acceptor_key) {
return Err(bad(
"the acceptor's key is not the key the offer was sent to",
));
}
if input.acceptor_key.is_empty() || input.acceptor_key == sent.key_id {
return Err(bad("the acceptor's key is empty or the offerer's"));
}
let row = of.terms_rows.rows.iter().rev().find(|r| r.id == input.row);
let Some(row) = row.filter(|r| is_payment_row(r)) else {
return Err(bad(format!(
"{:?} is not a payment row of the offer",
input.row
)));
};
let mut out = PaymentResult {
checked_over: vec![sent.digest.clone()],
..Default::default()
};
if payment_rows(&of.terms_rows).len() != 1 {
out.reason = REASON_SEVERAL_PAYMENTS.into();
return Ok(out);
}
let offer_record = record_of(&input.offer)?;
let offerer = of.role.as_str();
let acceptor = if offerer == ROLE_BUYER {
ROLE_SELLER
} else {
ROLE_BUYER
};
let mut role_of: HashMap<String, &'static str> = HashMap::new();
role_of.insert(sent.key_id.clone(), settlement_role(offerer, &row.owed_by));
role_of.insert(
input.acceptor_key.clone(),
settlement_role(acceptor, &row.owed_by),
);
struct LegRead {
read: BookRead,
capsule: Map<String, Value>,
refund: bool,
}
let mut legs: Vec<LegRead> = Vec::new();
let mut supersedes: Vec<(String, Ref, u64)> = Vec::new();
for (i, raw) in input.legs.iter().enumerate() {
let read = verify_book(raw)?;
if read.record.block.deal_id != sent.record.block.deal_id {
return Err(bad(format!(
"leg {i} is of deal {:?}, not the offer's",
read.record.block.deal_id
)));
}
let Body::Settle(body) = &read.record.body else {
continue;
};
let body = body.clone();
let Some(&role) = role_of.get(&read.key_id) else {
return Err(bad(format!("leg {i} is signed by neither party's key")));
};
if let Some(target) = &body.supersedes {
supersedes.push((read.key_id.clone(), target.clone(), read.seq));
}
let capsule = record_of(raw)?;
if capsule.get("chain").is_some_and(|c| !c.is_null()) {
return Err(bad(format!(
"leg {i}'s Capsule carries a chain; a deal-book record's has none"
)));
}
let Some(member) = capsule.get(SETTLEMENT_MEMBER).and_then(member_of) else {
out.excluded.push(read.digest.clone());
continue;
};
if member.terms_ref != sent.capsule_id {
continue; }
let refund = body.reverses.is_some() || body.remedy_for.is_some();
if !refund
&& (body.leg != role
|| member.leg != format!("{role}_observed")
|| member.sealer_role != role)
{
out.excluded.push(read.digest.clone());
continue;
}
legs.push(LegRead {
read,
capsule,
refund,
});
}
let superseded: HashSet<String> = legs
.iter()
.filter(|l| {
supersedes.iter().any(|(key, target, seq)| {
*key == l.read.key_id && *target == ref_to(&l.read.digest) && l.read.seq < *seq
})
})
.map(|l| l.read.digest.clone())
.collect();
if legs
.iter()
.any(|l| l.refund && !superseded.contains(&l.read.digest))
{
out.reason = REASON_REFUND_CITES_OFFER.into();
return Ok(out);
}
let mut capsules = vec![Value::Object(offer_record)];
let mut digest_of: HashMap<String, String> = HashMap::new(); let mut read = Vec::new();
for l in &legs {
if superseded.contains(&l.read.digest) {
continue;
}
capsules.push(Value::Object(l.capsule.clone()));
digest_of.insert(l.read.record_id.clone(), l.read.digest.clone());
read.push(l.read.digest.clone());
}
let mut policy: BTreeMap<String, Vec<String>> = BTreeMap::new();
for (key, role) in &role_of {
policy
.entry((*role).to_string())
.or_default()
.push(key.clone());
}
for keys in policy.values_mut() {
keys.sort();
}
let res = verify_settlements(
&capsules,
&SettlementOptions {
key_policy: Some(policy),
..Default::default()
},
);
let mut refused = HashSet::new();
for f in &res.failures {
for r in &f.records {
match r.as_ref().and_then(|id| digest_of.get(id)) {
Some(d) => {
refused.insert(d.clone());
}
None => {
return Err(bad(format!(
"AAC's verifier refuses the offer's terms leg: {}",
f.code
)))
}
}
}
}
for d in read {
if refused.contains(&d) {
out.excluded.push(d);
} else {
out.checked_over.push(d);
}
}
let Some(s) = res
.settlements
.iter()
.rev()
.find(|s| s.terms == sent.capsule_id)
else {
return Err(bad(format!(
"AAC's verifier read no terms leg {}",
sent.capsule_id
)));
};
out.settlement = Some(s.to_json());
let agreed = s.agreed_status.as_deref().unwrap_or("");
match s.payment_state.as_deref() {
Some("unjoined") => out.reason = REASON_UNJOINED.into(),
Some("mismatch") => {
out.check = PAYMENT_FAIL.into();
out.reason = REASON_MISMATCH.into();
}
Some("agreed") if agreed == "failed" || agreed == "reversed" => {
out.check = PAYMENT_FAIL.into();
out.reason = REASON_STATUS.into();
}
Some("agreed") if s.terms_amount.as_deref() != Some("equal") => {
out.check = PAYMENT_FAIL.into();
out.reason = REASON_AMOUNT.into();
}
Some("agreed") if agreed == "settled" => out.check = PAYMENT_PASS.into(),
Some("agreed") => out.reason = REASON_PENDING.into(),
_ => out.reason = REASON_NOT_AGREED.into(),
}
Ok(out)
}
struct Member {
leg: String,
sealer_role: String,
terms_ref: String,
}
fn member_of(v: &Value) -> Option<Member> {
if v.is_null() {
return Some(Member {
leg: String::new(),
sealer_role: String::new(),
terms_ref: String::new(),
});
}
let o = v.as_object()?;
super::exact::exact_object(v, &super::exact::SETTLEMENT, true, "the settlement member").ok()?;
let text = |k: &str| match o.get(k) {
None | Some(Value::Null) => Some(String::new()),
Some(Value::String(s)) => Some(s.clone()),
Some(_) => None,
};
Some(Member {
leg: text("leg")?,
sealer_role: text("sealer_role")?,
terms_ref: text("terms_ref")?,
})
}