use serde::{Deserialize, Serialize};
use crate::error::{AccountError, Result};
pub const DEFAULT_PERIOD_SECONDS: u64 = 24 * 60 * 60;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SpendOpClass {
Rebalance,
Tip,
SmallSend,
Undeclared,
}
impl SpendOpClass {
pub const CONFIGURABLE: [SpendOpClass; 3] = [Self::Rebalance, Self::Tip, Self::SmallSend];
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct OpClassLimits {
pub enabled: bool,
pub per_tx_limit_mojos: u64,
}
impl OpClassLimits {
pub fn enabled_up_to(per_tx_limit_mojos: u64) -> Self {
Self {
enabled: true,
per_tx_limit_mojos,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct AutoSendPolicy {
pub enabled: bool,
pub rebalance: OpClassLimits,
pub tip: OpClassLimits,
pub small_send: OpClassLimits,
pub period_seconds: u64,
pub period_cap_mojos: u64,
}
impl Default for AutoSendPolicy {
fn default() -> Self {
Self {
enabled: false,
rebalance: OpClassLimits::default(),
tip: OpClassLimits::default(),
small_send: OpClassLimits::default(),
period_seconds: DEFAULT_PERIOD_SECONDS,
period_cap_mojos: 0,
}
}
}
impl AutoSendPolicy {
pub fn limits_for(&self, op_class: SpendOpClass) -> Result<OpClassLimits> {
match op_class {
SpendOpClass::Rebalance => Ok(self.rebalance),
SpendOpClass::Tip => Ok(self.tip),
SpendOpClass::SmallSend => Ok(self.small_send),
SpendOpClass::Undeclared => Err(AccountError::PolicyIndeterminate(
"the caller did not declare what this spend is for, so no auto-send limit applies"
.to_string(),
)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_default_policy_auto_approves_nothing() {
let policy = AutoSendPolicy::default();
assert!(!policy.enabled, "the global switch must default to off");
assert_eq!(policy.period_cap_mojos, 0);
assert_eq!(policy.period_seconds, DEFAULT_PERIOD_SECONDS);
for op_class in SpendOpClass::CONFIGURABLE {
let limits = policy.limits_for(op_class).unwrap();
assert!(!limits.enabled, "{op_class:?} must default to disabled");
assert_eq!(
limits.per_tx_limit_mojos, 0,
"{op_class:?} must default to a zero per-tx limit"
);
}
}
#[test]
fn every_configurable_op_class_maps_to_its_own_limits() {
let policy = AutoSendPolicy {
rebalance: OpClassLimits::enabled_up_to(1),
tip: OpClassLimits::enabled_up_to(2),
small_send: OpClassLimits::enabled_up_to(3),
..AutoSendPolicy::default()
};
assert_eq!(
policy
.limits_for(SpendOpClass::Rebalance)
.unwrap()
.per_tx_limit_mojos,
1
);
assert_eq!(
policy
.limits_for(SpendOpClass::Tip)
.unwrap()
.per_tx_limit_mojos,
2
);
assert_eq!(
policy
.limits_for(SpendOpClass::SmallSend)
.unwrap()
.per_tx_limit_mojos,
3
);
}
#[test]
fn an_undeclared_op_class_has_no_limits_and_is_indeterminate() {
let permissive = AutoSendPolicy {
enabled: true,
rebalance: OpClassLimits::enabled_up_to(u64::MAX),
tip: OpClassLimits::enabled_up_to(u64::MAX),
small_send: OpClassLimits::enabled_up_to(u64::MAX),
period_cap_mojos: u64::MAX,
..AutoSendPolicy::default()
};
let err = permissive.limits_for(SpendOpClass::Undeclared).unwrap_err();
assert!(matches!(err, AccountError::PolicyIndeterminate(_)), "{err}");
}
#[test]
fn an_empty_persisted_policy_deserializes_to_the_refusing_default() {
let policy: AutoSendPolicy = serde_json::from_str("{}").unwrap();
assert_eq!(policy, AutoSendPolicy::default());
}
#[test]
fn an_omitted_op_class_stays_disabled_while_its_sibling_is_enabled() {
let policy: AutoSendPolicy = serde_json::from_str(
r#"{"enabled": true, "tip": {"enabled": true, "per_tx_limit_mojos": 500},
"period_cap_mojos": 5000}"#,
)
.unwrap();
assert!(policy.tip.enabled);
assert!(
!policy.rebalance.enabled,
"an omitted class must not inherit its sibling's permission"
);
assert_eq!(policy.rebalance.per_tx_limit_mojos, 0);
assert!(!policy.small_send.enabled);
}
#[test]
fn a_mistyped_policy_key_is_rejected_rather_than_ignored() {
let err = serde_json::from_str::<AutoSendPolicy>(r#"{"enable": true}"#).unwrap_err();
assert!(err.to_string().contains("unknown field"), "{err}");
}
#[test]
fn a_policy_round_trips_through_json() {
let policy = AutoSendPolicy {
enabled: true,
rebalance: OpClassLimits::enabled_up_to(100),
tip: OpClassLimits::enabled_up_to(25),
small_send: OpClassLimits::default(),
period_seconds: 3_600,
period_cap_mojos: 1_000,
};
let json = serde_json::to_string(&policy).unwrap();
assert_eq!(
serde_json::from_str::<AutoSendPolicy>(&json).unwrap(),
policy
);
}
#[test]
fn enabled_up_to_builds_an_enabled_bound() {
let limits = OpClassLimits::enabled_up_to(7);
assert!(limits.enabled);
assert_eq!(limits.per_tx_limit_mojos, 7);
}
#[test]
fn op_class_configurable_lists_every_class_except_undeclared() {
assert_eq!(SpendOpClass::CONFIGURABLE.len(), 3);
assert!(!SpendOpClass::CONFIGURABLE.contains(&SpendOpClass::Undeclared));
for op_class in [
SpendOpClass::Rebalance,
SpendOpClass::Tip,
SpendOpClass::SmallSend,
SpendOpClass::Undeclared,
] {
let configurable = match op_class {
SpendOpClass::Rebalance | SpendOpClass::Tip | SpendOpClass::SmallSend => true,
SpendOpClass::Undeclared => false,
};
assert_eq!(
SpendOpClass::CONFIGURABLE.contains(&op_class),
configurable,
"{op_class:?}"
);
}
}
}