use std::{collections::HashSet, sync::Arc};
use async_trait::async_trait;
use color_eyre::Result;
use rust_decimal::Decimal;
use serde::Deserialize;
use tokio::sync::Mutex;
use crate::{
ports::WalletGateway,
strategies::{CommonParams, Strategy, params_from_table},
};
#[derive(Debug, Clone, Deserialize)]
pub struct DepositTransferConfig {
#[serde(flatten)]
pub common: CommonParams,
pub dest_label: String,
#[serde(default)]
pub ignore_below: Decimal,
}
impl DepositTransferConfig {
pub fn from_params(table: &toml::Table) -> Result<Self> {
params_from_table(table)
}
}
pub struct DepositTransfer {
config: DepositTransferConfig,
wallet: Arc<dyn WalletGateway>,
seen: Mutex<HashSet<String>>,
}
impl DepositTransfer {
pub fn new(config: DepositTransferConfig, wallet: Arc<dyn WalletGateway>) -> Self {
Self { config, wallet, seen: Mutex::new(HashSet::new()) }
}
pub async fn tick(&self) -> Result<usize> {
let exchange = self.config.common.proto_exchange_id();
let deposits = self.wallet.fetch_deposits(&exchange, 50).await?;
let mut transferred = 0;
let mut seen = self.seen.lock().await;
for entry in deposits {
if !entry.completed {
continue;
}
if entry.amount <= Decimal::ZERO {
continue;
}
if entry.amount < self.config.ignore_below {
continue;
}
if seen.contains(&entry.id) {
continue;
}
self.wallet
.transfer(
&exchange,
&entry.currency,
entry.amount,
&self.config.dest_label,
&format!("deposit-sweep:{}", entry.id),
)
.await?;
seen.insert(entry.id.clone());
tracing::info!(
currency = %entry.currency,
amount = %entry.amount,
dest = %self.config.dest_label,
"deposit swept"
);
transferred += 1;
}
Ok(transferred)
}
}
#[async_trait]
impl Strategy for DepositTransfer {
async fn run(&self) -> Result<()> {
let poll = std::time::Duration::from_secs(self.config.common.poll_secs.max(1));
loop {
if let Err(err) = self.tick().await {
tracing::error!(error = %err, "deposit-transfer tick failed");
}
tokio::time::sleep(poll).await;
}
}
}
#[cfg(test)]
mod tests {
use std::sync::{
Arc as StdArc, Mutex as StdMutex,
atomic::{AtomicBool, Ordering},
};
use async_trait::async_trait;
use rust_decimal_macros::dec;
use super::*;
use crate::{
adapters::MockAdapter,
ports::{LedgerEntry, PortError, TradingGateway, TransferReceipt},
proto::common,
};
fn deposit(id: &str, amount: Decimal) -> crate::ports::LedgerEntry {
crate::ports::LedgerEntry {
id: id.to_string(),
currency: String::from("USDT"),
amount,
entry_type: String::from("deposit"),
completed: true,
time_ms: 0,
}
}
#[tokio::test]
async fn sweeps_each_completed_deposit_once() {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
adapter.push_deposit(deposit("d1", dec!(50))).await;
adapter.push_deposit(deposit("d2", dec!(30))).await;
let config = DepositTransferConfig::from_params(
&toml::from_str("symbol = \"BTCUSDT\"\ndest_label = \"master\"").expect("toml"),
)
.expect("config");
let _gateway: StdArc<dyn TradingGateway> = adapter.clone();
let wallet: StdArc<dyn WalletGateway> = adapter.clone();
let s = DepositTransfer::new(config, wallet);
assert_eq!(s.tick().await.expect("tick"), 2);
assert_eq!(s.tick().await.expect("tick"), 0);
assert_eq!(adapter.transfers().await.len(), 2);
assert_eq!(adapter.transfers().await[0].2, "master");
}
#[tokio::test]
async fn ignores_incomplete_and_dust() {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
let mut pending = deposit("p1", dec!(99));
pending.completed = false;
adapter.push_deposit(pending).await;
adapter.push_deposit(deposit("dust", dec!(1))).await;
let config = DepositTransferConfig::from_params(
&toml::from_str("symbol = \"BTCUSDT\"\ndest_label = \"master\"\nignore_below = \"10\"")
.expect("toml"),
)
.expect("config");
let _gateway: StdArc<dyn TradingGateway> = adapter.clone();
let wallet: StdArc<dyn WalletGateway> = adapter.clone();
let s = DepositTransfer::new(config, wallet);
assert_eq!(s.tick().await.expect("tick"), 0);
}
#[derive(Clone, Default)]
struct StubWallet {
deposits: StdArc<StdMutex<Vec<LedgerEntry>>>,
reads: StdArc<StdMutex<Vec<(String, String, u32)>>>,
keys: StdArc<StdMutex<Vec<String>>>,
fail_reads: StdArc<AtomicBool>,
fail_transfers: StdArc<AtomicBool>,
}
impl StubWallet {
fn holding(entries: Vec<LedgerEntry>) -> Self {
Self { deposits: StdArc::new(StdMutex::new(entries)), ..Self::default() }
}
fn replace_deposits(&self, entries: Vec<LedgerEntry>) {
*self.deposits.lock().expect("wallet log") = entries;
}
fn refusing_reads(self) -> Self {
self.fail_reads.store(true, Ordering::SeqCst);
self
}
fn refusing_transfers(self) -> Self {
self.fail_transfers.store(true, Ordering::SeqCst);
self
}
fn allowing_transfers(&self) {
self.fail_transfers.store(false, Ordering::SeqCst);
}
fn reads(&self) -> Vec<(String, String, u32)> {
self.reads.lock().expect("wallet log").clone()
}
fn transfer_keys(&self) -> Vec<String> {
self.keys.lock().expect("wallet log").clone()
}
}
#[async_trait]
impl WalletGateway for StubWallet {
async fn list_ledger_entries(
&self,
_exchange_id: &common::ExchangeId,
currency: &str,
entry_type: &str,
limit: u32,
) -> Result<Vec<LedgerEntry>, PortError> {
if self.fail_reads.load(Ordering::SeqCst) {
return Err(PortError::Transport("ledger unavailable".into()));
}
self.reads.lock().expect("wallet log").push((
currency.to_string(),
entry_type.to_string(),
limit,
));
let rows = self.deposits.lock().expect("wallet log").clone();
Ok(rows
.into_iter()
.filter(|row| currency.is_empty() || row.currency == currency)
.filter(|row| entry_type.is_empty() || row.entry_type == entry_type)
.take(limit as usize)
.collect())
}
async fn transfer(
&self,
_exchange_id: &common::ExchangeId,
asset: &str,
amount: Decimal,
_dest_label: &str,
client_transfer_id: &str,
) -> Result<TransferReceipt, PortError> {
if self.fail_transfers.load(Ordering::SeqCst) {
return Err(PortError::Transport("transfer refused".into()));
}
self.keys.lock().expect("wallet log").push(client_transfer_id.to_string());
Ok(TransferReceipt {
transfer_id: client_transfer_id.to_string(),
entry: Some(LedgerEntry {
id: client_transfer_id.to_string(),
currency: asset.to_string(),
amount: -amount,
entry_type: "transfer".into(),
completed: true,
time_ms: 0,
}),
})
}
}
fn sweeper(wallet: StubWallet, doc: &str) -> DepositTransfer {
let full = format!("symbol = \"BTCUSDT\"\ndest_label = \"master\"\n{doc}");
let config = DepositTransferConfig::from_params(&toml::from_str(&full).expect("toml"))
.expect("config");
DepositTransfer::new(config, StdArc::new(wallet))
}
#[tokio::test]
async fn the_ledger_is_read_as_deposits_with_a_limit_of_fifty() {
let wallet = StubWallet::holding(vec![deposit("d1", dec!(5))]);
let s = sweeper(wallet.clone(), "");
assert_eq!(s.tick().await.expect("tick"), 1);
assert_eq!(wallet.reads(), vec![(String::new(), "deposit".to_string(), 50)]);
}
#[tokio::test]
async fn a_zero_amount_deposit_is_skipped_when_nothing_is_ignored() {
let wallet = StubWallet::holding(vec![deposit("zero", Decimal::ZERO)]);
let s = sweeper(wallet.clone(), "");
assert_eq!(s.tick().await.expect("tick"), 0, "a transfer of zero is not a sweep");
assert!(wallet.transfer_keys().is_empty(), "the venue must never be asked to move zero");
}
#[tokio::test]
async fn a_venue_that_refuses_zero_amount_transfers_is_never_asked() {
let adapter = StdArc::new(MockAdapter::new(dec!(100)));
adapter.push_deposit(deposit("zero", Decimal::ZERO)).await;
let config = DepositTransferConfig::from_params(
&toml::from_str("symbol = \"BTCUSDT\"\ndest_label = \"master\"").expect("toml"),
)
.expect("config");
let wallet: StdArc<dyn WalletGateway> = adapter.clone();
let s = DepositTransfer::new(config, wallet);
assert_eq!(s.tick().await.expect("tick"), 0);
assert!(adapter.transfers().await.is_empty(), "no funds must have moved");
}
#[tokio::test]
async fn a_negative_amount_deposit_is_skipped() {
let wallet = StubWallet::holding(vec![deposit("out", dec!(-50))]);
let s = sweeper(wallet.clone(), "ignore_below = \"-100\"");
assert_eq!(s.tick().await.expect("tick"), 0);
assert!(wallet.transfer_keys().is_empty());
}
#[tokio::test]
async fn a_deposit_whose_transfer_failed_is_retried_on_the_next_cycle() {
let wallet = StubWallet::holding(vec![deposit("d1", dec!(50))]).refusing_transfers();
let s = sweeper(wallet.clone(), "");
assert!(s.tick().await.is_err(), "a refused transfer must surface");
wallet.allowing_transfers();
assert_eq!(s.tick().await.expect("second cycle"), 1, "the failed sweep was not lost");
assert_eq!(wallet.transfer_keys(), vec!["deposit-sweep:d1".to_string()]);
}
#[tokio::test]
async fn a_deposit_below_the_floor_is_swept_once_it_grows() {
let wallet = StubWallet::holding(vec![deposit("d1", dec!(5))]);
let s = sweeper(wallet.clone(), "ignore_below = \"10\"");
assert_eq!(s.tick().await.expect("tick"), 0);
wallet.replace_deposits(vec![deposit("d1", dec!(50))]);
assert_eq!(s.tick().await.expect("tick"), 1, "the filter ran before the seen check");
assert_eq!(wallet.transfer_keys(), vec!["deposit-sweep:d1".to_string()]);
}
#[tokio::test]
async fn a_deposit_that_completes_later_is_swept_on_the_next_cycle() {
let mut pending = deposit("p1", dec!(50));
pending.completed = false;
let wallet = StubWallet::holding(vec![pending]);
let s = sweeper(wallet.clone(), "");
assert_eq!(s.tick().await.expect("tick"), 0);
wallet.replace_deposits(vec![deposit("p1", dec!(50))]);
assert_eq!(s.tick().await.expect("tick"), 1);
assert_eq!(wallet.transfer_keys(), vec!["deposit-sweep:p1".to_string()]);
}
#[tokio::test]
async fn the_transfer_key_names_the_deposit_it_moves() {
let wallet = StubWallet::holding(vec![deposit("d1", dec!(50)), deposit("d2", dec!(30))]);
let s = sweeper(wallet.clone(), "");
assert_eq!(s.tick().await.expect("tick"), 2);
assert_eq!(
wallet.transfer_keys(),
vec!["deposit-sweep:d1".to_string(), "deposit-sweep:d2".to_string()]
);
}
#[tokio::test]
async fn a_failed_ledger_read_propagates() {
let wallet = StubWallet::holding(Vec::new()).refusing_reads();
let s = sweeper(wallet, "");
let err = s.tick().await.expect_err("an unreadable ledger must surface");
assert!(err.to_string().contains("ledger unavailable"), "{err}");
}
#[test]
fn the_dust_floor_defaults_to_zero() {
let table: toml::Table =
toml::from_str("symbol = \"BTCUSDT\"\ndest_label = \"master\"").expect("toml");
let cfg = DepositTransferConfig::from_params(&table).expect("config");
assert_eq!(cfg.ignore_below, Decimal::ZERO);
}
}