use serde::{Deserialize, Serialize};
pub const DEFAULT_PERIOD_SECONDS: u64 = 24 * 60 * 60;
pub const DEFAULT_MAX_CONFIRMATIONS_PER_PERIOD: u32 = 64;
pub const MAX_LEDGER_ENTRIES: usize = 4_096;
#[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,
pub max_confirmations_per_period: u32,
}
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,
max_confirmations_per_period: DEFAULT_MAX_CONFIRMATIONS_PER_PERIOD,
}
}
}
impl AutoSendPolicy {
pub fn configured_limits(&self, op_class: SpendOpClass) -> Option<OpClassLimits> {
match op_class {
SpendOpClass::Rebalance => Some(self.rebalance),
SpendOpClass::Tip => Some(self.tip),
SpendOpClass::SmallSend => Some(self.small_send),
SpendOpClass::Undeclared => None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_default_rolling_window_is_exactly_twenty_four_hours() {
assert_eq!(DEFAULT_PERIOD_SECONDS, 86_400);
}
#[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.configured_limits(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
.configured_limits(SpendOpClass::Rebalance)
.unwrap()
.per_tx_limit_mojos,
1
);
assert_eq!(
policy
.configured_limits(SpendOpClass::Tip)
.unwrap()
.per_tx_limit_mojos,
2
);
assert_eq!(
policy
.configured_limits(SpendOpClass::SmallSend)
.unwrap()
.per_tx_limit_mojos,
3
);
}
#[test]
fn an_undeclared_op_class_has_no_configured_bounds_while_declared_ones_do() {
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()
};
for declared in SpendOpClass::CONFIGURABLE {
assert!(
permissive.configured_limits(declared).is_some(),
"{declared:?} is configurable and must have bounds"
);
}
assert!(permissive
.configured_limits(SpendOpClass::Undeclared)
.is_none());
}
#[test]
fn the_confirmation_ceiling_defaults_to_a_usable_non_zero_bound() {
assert_eq!(DEFAULT_MAX_CONFIRMATIONS_PER_PERIOD, 64);
assert_eq!(
AutoSendPolicy::default().max_confirmations_per_period,
DEFAULT_MAX_CONFIRMATIONS_PER_PERIOD,
"the refusing default must still permit a person to be asked"
);
assert!(
AutoSendPolicy::default().max_confirmations_per_period > 0,
"a zero ceiling would make every confirmable spend unspendable"
);
}
#[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,
max_confirmations_per_period: 8,
};
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:?}"
);
}
}
}