use std::fmt;
use chia_protocol::CoinSpend;
use dig_wallet_backend::client::derive_summary;
use crate::error::{AccountError, Result};
use crate::wallet::policy::CustodyPolicy;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SpendRecipient {
pub address: String,
pub amount_mojos: u64,
pub asset_id: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SpendTier {
AutoSend,
Confirm,
Vault,
}
impl SpendTier {
pub fn classify(policy: &CustodyPolicy, total_mojos: u64) -> Self {
match policy {
CustodyPolicy::Vault(_) => SpendTier::Vault,
CustodyPolicy::Hot(hot) if total_mojos <= hot.auto_send_limit => SpendTier::AutoSend,
CustodyPolicy::Hot(_) => SpendTier::Confirm,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SpendSummary {
pub tier: SpendTier,
pub recipients: Vec<SpendRecipient>,
pub fee: u64,
}
impl SpendSummary {
pub fn new(tier: SpendTier, recipients: Vec<SpendRecipient>, fee: u64) -> Self {
Self {
tier,
recipients,
fee,
}
}
pub fn from_coin_spends(coin_spends: &[CoinSpend], tier: SpendTier) -> Result<Self> {
let derived = derive_summary(coin_spends)
.map_err(|e| AccountError::Spend(format!("cannot derive spend summary: {e}")))?;
let recipients = derived
.outputs
.into_iter()
.map(|output| SpendRecipient {
address: output.address.0,
amount_mojos: output.amount.mojos(),
asset_id: output.asset_id.map(|asset| asset.0),
})
.collect();
Ok(Self {
tier,
recipients,
fee: derived.fee.mojos(),
})
}
pub fn classified(coin_spends: &[CoinSpend], policy: &CustodyPolicy) -> Result<Self> {
let mut summary = Self::from_coin_spends(coin_spends, SpendTier::Confirm)?;
summary.tier = SpendTier::classify(policy, summary.checked_native_total_mojos()?);
Ok(summary)
}
pub fn native_total_mojos(&self) -> u64 {
self.checked_native_total_mojos().unwrap_or(u64::MAX)
}
pub fn checked_native_total_mojos(&self) -> Result<u64> {
let native_out = self
.recipients
.iter()
.filter(|recipient| recipient.asset_id.is_none())
.try_fold(0u64, |sum, recipient| {
sum.checked_add(recipient.amount_mojos)
})
.ok_or_else(|| Self::unsummable("the native recipient amounts"))?;
native_out
.checked_add(self.fee)
.ok_or_else(|| Self::unsummable("the native recipient amounts plus the fee"))
}
fn unsummable(what: &str) -> AccountError {
AccountError::PolicyIndeterminate(format!(
"{what} overflow u64, so this spend has no native total to weigh against a limit"
))
}
}
impl fmt::Display for SpendSummary {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}: ", self.tier)?;
if self.recipients.is_empty() {
write!(f, "no recipients")?;
} else {
for (i, recipient) in self.recipients.iter().enumerate() {
if i > 0 {
write!(f, ", ")?;
}
let asset = recipient.asset_id.as_deref().unwrap_or("XCH");
write!(
f,
"{} {} -> {}",
recipient.amount_mojos, asset, recipient.address
)?;
}
}
write!(f, " (fee {} mojos)", self.fee)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::wallet::policy::{HotWallet, Vault};
#[test]
fn classify_maps_vault_to_the_vault_tier() {
assert_eq!(
SpendTier::classify(&CustodyPolicy::Vault(Vault::default()), 1),
SpendTier::Vault
);
}
#[test]
fn classify_auto_sends_within_the_hot_allowance() {
let policy = CustodyPolicy::Hot(HotWallet {
auto_send_limit: 1_000,
});
assert_eq!(SpendTier::classify(&policy, 1_000), SpendTier::AutoSend);
assert_eq!(SpendTier::classify(&policy, 1_001), SpendTier::Confirm);
}
#[test]
fn classify_confirms_every_spend_on_a_zero_allowance_hot_wallet() {
let policy = CustodyPolicy::Hot(HotWallet::default());
assert_eq!(SpendTier::classify(&policy, 0), SpendTier::AutoSend);
assert_eq!(SpendTier::classify(&policy, 1), SpendTier::Confirm);
}
#[test]
fn native_total_sums_xch_recipients_and_fee_ignoring_cats() {
let summary = SpendSummary::new(
SpendTier::Confirm,
vec![
SpendRecipient {
address: "xch1a".into(),
amount_mojos: 600,
asset_id: None,
},
SpendRecipient {
address: "xch1b".into(),
amount_mojos: 999,
asset_id: Some("deadbeef".into()),
},
],
10,
);
assert_eq!(summary.native_total_mojos(), 610);
}
#[test]
fn display_renders_recipients_and_fee() {
let summary = SpendSummary::new(
SpendTier::AutoSend,
vec![SpendRecipient {
address: "xch1abc".into(),
amount_mojos: 42,
asset_id: None,
}],
5,
);
let line = summary.to_string();
assert!(line.contains("42 XCH -> xch1abc"), "{line}");
assert!(line.contains("fee 5 mojos"), "{line}");
}
#[test]
fn a_non_decodable_coin_spend_set_is_refused() {
let err = SpendSummary::from_coin_spends(&[], SpendTier::Confirm).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)));
let err =
SpendSummary::classified(&[], &CustodyPolicy::Hot(HotWallet::default())).unwrap_err();
assert!(matches!(err, AccountError::Spend(_)));
}
#[test]
fn display_handles_a_summary_with_no_recipients() {
let summary = SpendSummary::new(SpendTier::Vault, vec![], 3);
let line = summary.to_string();
assert!(line.contains("no recipients"), "{line}");
assert!(line.contains("fee 3 mojos"), "{line}");
}
#[test]
fn display_names_a_cat_asset() {
let summary = SpendSummary::new(
SpendTier::Confirm,
vec![SpendRecipient {
address: "xch1cat".into(),
amount_mojos: 7,
asset_id: Some("cafe".into()),
}],
0,
);
assert!(summary.to_string().contains("7 cafe -> xch1cat"));
}
#[test]
fn classified_re_derives_and_tiers_a_real_send() {
use crate::id::ProfileIx;
use crate::keys::wallet_key::WalletKey;
use chia_protocol::{Bytes32, Coin};
use chia_puzzle_types::Memos;
use chia_wallet_sdk::driver::{SpendContext, StandardLayer};
use chia_wallet_sdk::types::Conditions;
let key = WalletKey::from_seed_at(&[0x42u8; 32], ProfileIx::ROOT);
let mut ctx = SpendContext::new();
let coin = Coin::new(Bytes32::new([1u8; 32]), key.puzzle_hash(), 1_000);
let recipient = Bytes32::new([7u8; 32]);
let hint = ctx.hint(recipient).unwrap();
let conditions = Conditions::new()
.create_coin(recipient, 600, hint)
.create_coin(key.puzzle_hash(), 390, Memos::None)
.reserve_fee(10);
StandardLayer::new(key.public_key())
.spend(&mut ctx, coin, conditions)
.unwrap();
let coin_spends = ctx.take();
let policy = CustodyPolicy::Hot(HotWallet {
auto_send_limit: 1_000,
});
let summary = SpendSummary::classified(&coin_spends, &policy).unwrap();
assert_eq!(summary.recipients.len(), 1);
assert_eq!(summary.recipients[0].amount_mojos, 600);
assert_eq!(summary.fee, 10);
assert_eq!(summary.tier, SpendTier::AutoSend);
}
}