use std::sync::Arc;
use alloy::primitives::{address, Address};
use degenbot_aave::updater::verify::cleanup_zero_balance_positions_on_conn;
use degenbot_aave::{
activate_aave_market, deactivate_aave_market, reset_market_to_cold_boot, run_aave_update,
NoProgress, RunError, RunSpec, VerifyPolicy,
};
use degenbot_db::{
aave_market_digest_for, ops, parse_completed_market_manifest, CompletedMarketDrive,
CompletedMarketManifest, DbError, DegenbotDb,
};
use degenbot_rpc::provider::AlloyProvider;
use crate::block::{parse_to_block, resolve_to_block};
use crate::cancel::CancelHandle;
use crate::context::CliContext;
use crate::error::CliError;
use crate::prompt::{PromptPlan, Prompter};
use crate::report::{
AavePositionLine, AaveReinit, AaveReport, AaveUpdateEntry, AaveUpdateOutcome, DeactivateOutcome,
};
use degenbot_db::AaveMarketPurgeCount;
const RPC_MAX_RETRIES: u32 = 5;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AaveDeployment {
pub chain_id: u64,
pub chain_label: &'static str,
pub market_name: &'static str,
pub pool_address_provider: Address,
pub gho_token_address: Address,
}
pub const AAVE_DEPLOYMENTS: &[AaveDeployment] = &[AaveDeployment {
chain_id: 1,
chain_label: "Ethereum",
market_name: "Aave Ethereum Market",
pool_address_provider: address!("2f39d218133AFaB8F2B819B1066c7E434Ad94E9e"),
gho_token_address: address!("40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f"),
}];
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AaveCommand {
Activate {
chain_id: u64,
},
Deactivate {
chain_id: u64,
market_name: String,
},
Digest {
chain_id: u64,
market_name: Option<String>,
drive_manifest: Option<std::path::PathBuf>,
},
Update {
chunk_size: u64,
max_block_range: u64,
to_block: String,
verify_chunk: bool,
verify_all: bool,
verify_all_interval: u64,
stop_after_one_chunk: bool,
dry_run: bool,
enable_backup: bool,
},
Reset {
chain_id: u64,
market_name: Option<String>,
dry_run: bool,
},
PositionShow {
address: String,
market: String,
chain_id: u64,
},
}
impl AaveCommand {
#[must_use]
pub const fn prompt_plan(&self, _ctx: &CliContext<'_>) -> PromptPlan {
PromptPlan::None
}
}
pub fn resolve_aave_deployment(chain_id: u64) -> Result<&'static AaveDeployment, CliError> {
AAVE_DEPLOYMENTS
.iter()
.find(|d| d.chain_id == chain_id)
.ok_or_else(|| CliError::UnknownDeployment {
chain_id,
name: "ethereum_aave_v3".to_string(),
})
}
pub(crate) fn execute(
command: &AaveCommand,
ctx: &CliContext<'_>,
_prompter: &dyn Prompter,
cancel: &CancelHandle,
) -> Result<AaveReport, CliError> {
match command {
AaveCommand::Activate { chain_id } => activate(ctx, *chain_id),
AaveCommand::Deactivate {
chain_id,
market_name,
} => deactivate(ctx, *chain_id, market_name),
AaveCommand::Digest {
chain_id,
market_name,
drive_manifest,
} => digest(
ctx,
*chain_id,
market_name.as_deref(),
drive_manifest.as_deref(),
),
AaveCommand::Update {
chunk_size,
max_block_range,
to_block,
verify_chunk,
verify_all,
verify_all_interval,
stop_after_one_chunk,
dry_run,
enable_backup,
} => update(
ctx,
cancel,
&UpdateArgs {
chunk_size: *chunk_size,
max_block_range: *max_block_range,
to_block,
verify_chunk: *verify_chunk,
verify_all: *verify_all,
verify_all_interval: *verify_all_interval,
stop_after_one_chunk: *stop_after_one_chunk,
dry_run: *dry_run,
enable_backup: *enable_backup,
},
),
AaveCommand::Reset {
chain_id,
market_name,
dry_run,
} => reset(ctx, cancel, *chain_id, market_name.as_deref(), *dry_run),
AaveCommand::PositionShow {
address,
market,
chain_id,
} => position_show(ctx, address, market, *chain_id),
}
}
fn activate(ctx: &CliContext<'_>, chain_id: u64) -> Result<AaveReport, CliError> {
let deployment = resolve_aave_deployment(chain_id)?;
let database_path = ctx.database_path()?.value;
let rpc_url = ctx.node_request_uri_for(chain_id)?.value;
let chain = i64::try_from(chain_id)
.map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
let result = match crate::pool::shared_runtime_block_on(async {
AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
}) {
Ok(Ok(provider)) => activate_aave_market(
&database_path,
chain,
&deployment.pool_address_provider.to_checksum(None),
&deployment.gho_token_address.to_checksum(None),
&provider,
),
Ok(Err(err)) => Err(RunError::from(err)),
Err(cli_err) => return Err(cli_err),
}
.map_err(CliError::AaveUpdate)?;
tracing::info!(
chain_id,
market_id = result.market_id,
"activated Aave V3 market"
);
Ok(AaveReport::Activated {
chain_id,
chain_label: deployment.chain_label,
market_id: result.market_id,
market_name: result.market_name,
created: result.created,
})
}
fn deactivate(
ctx: &CliContext<'_>,
chain_id: u64,
market_name: &str,
) -> Result<AaveReport, CliError> {
let database_path = ctx.database_path()?.value;
let chain = i64::try_from(chain_id)
.map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
let market = {
let db = (DegenbotDb::open(&database_path)?).0;
db.fetch_aave_market_by_name(chain, market_name)?
};
let Some(market) = market else {
return Ok(AaveReport::Deactivated {
chain_id,
market_id: None,
outcome: DeactivateOutcome::NoEntry,
});
};
if !market.active {
return Ok(AaveReport::Deactivated {
chain_id,
market_id: Some(market.id),
outcome: DeactivateOutcome::AlreadyDeactivated,
});
}
deactivate_aave_market(&database_path, market.id).map_err(CliError::AaveUpdate)?;
tracing::info!(
chain_id,
market_id = market.id,
"deactivated Aave V3 market"
);
Ok(AaveReport::Deactivated {
chain_id,
market_id: Some(market.id),
outcome: DeactivateOutcome::Deactivated,
})
}
fn digest(
ctx: &CliContext<'_>,
chain_id: u64,
market_name: Option<&str>,
drive_manifest: Option<&std::path::Path>,
) -> Result<AaveReport, CliError> {
let database_path = ctx.database_path()?.value;
let chain = i64::try_from(chain_id)
.map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
let drive = drive_manifest.map(carried_drive).transpose()?;
let digest = {
let db = (DegenbotDb::open(&database_path)?).0;
let conn = db.lock();
aave_market_digest_for(&conn, Some(chain), market_name)?
};
Ok(AaveReport::Digest {
manifest: CompletedMarketManifest { digest, drive },
})
}
fn carried_drive(path: &std::path::Path) -> Result<CompletedMarketDrive, CliError> {
let raw = std::fs::read_to_string(path).map_err(CliError::Io)?;
let manifest = parse_completed_market_manifest(&raw)
.map_err(|error| CliError::InvalidArgument(format!("{}: {error}", path.display())))?;
manifest.drive.ok_or_else(|| {
CliError::InvalidArgument(format!("{} carries no market.drive block", path.display()))
})
}
#[expect(clippy::struct_excessive_bools)]
struct UpdateArgs<'a> {
chunk_size: u64,
max_block_range: u64,
to_block: &'a str,
verify_chunk: bool,
verify_all: bool,
verify_all_interval: u64,
stop_after_one_chunk: bool,
dry_run: bool,
enable_backup: bool,
}
impl From<&UpdateArgs<'_>> for VerifyPolicy {
fn from(args: &UpdateArgs<'_>) -> Self {
Self {
verify_chunk: args.verify_chunk,
verify_all_interval: args.verify_all.then_some(args.verify_all_interval),
verify_all_at_completion: args.verify_all,
}
}
}
#[expect(clippy::too_many_lines)]
fn update(
ctx: &CliContext<'_>,
cancel: &CancelHandle,
args: &UpdateArgs<'_>,
) -> Result<AaveReport, CliError> {
let database_path = ctx.database_path()?.value;
crate::registrations::ensure_supported_registrations(&database_path)?;
let markets = {
let db = (DegenbotDb::open(&database_path)?).0;
db.fetch_active_aave_markets()?
};
if markets.is_empty() {
return Err(CliError::NoActiveAaveMarkets);
}
let spec = parse_to_block(args.to_block)?;
let max_chunks = if args.stop_after_one_chunk {
Some(1)
} else {
None
};
let mut entries: Vec<AaveUpdateEntry> = Vec::new();
let mut chain_ids: Vec<i64> = Vec::new();
for market in &markets {
if !chain_ids.contains(&market.chain_id) {
chain_ids.push(market.chain_id);
}
}
for chain in chain_ids {
if cancel.is_cancelled() {
break;
}
let chain_unsigned = u64::try_from(chain).map_err(|_| {
CliError::InvalidArgument(format!("market chain id {chain} is out of range"))
})?;
let rpc_url = ctx.node_request_uri_for(chain_unsigned)?.value;
let resolved = resolve_to_block(spec, &rpc_url)?;
for market in markets.iter().filter(|m| m.chain_id == chain) {
if cancel.is_cancelled() {
return Ok(AaveReport::Updated { entries });
}
let Some(last_update_block) = market.last_update_block else {
entries.push(AaveUpdateEntry {
chain_id: chain,
market_id: market.id,
market_name: market.name.clone(),
outcome: AaveUpdateOutcome::NeedsBootstrap,
});
continue;
};
if args.dry_run {
entries.push(AaveUpdateEntry {
chain_id: chain,
market_id: market.id,
market_name: market.name.clone(),
outcome: AaveUpdateOutcome::DryRun {
last_update_block,
to_block: resolved,
},
});
continue;
}
let run = match crate::pool::shared_runtime_block_on(async {
AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
}) {
Ok(Ok(provider)) => run_aave_update(
&database_path,
RunSpec {
chain_id: chain,
market_id: market.id,
to_block: resolved,
chunk_size: args.chunk_size,
max_block_range: args.max_block_range,
provider,
cancel: cancel.flag(),
progress: Arc::new(NoProgress),
verify: VerifyPolicy::from(args),
max_chunks,
},
),
Ok(Err(err)) => Err(RunError::from(err)),
Err(cli_err) => return Err(cli_err),
};
match run {
Ok(report) => {
entries.push(AaveUpdateEntry {
chain_id: chain,
market_id: market.id,
market_name: market.name.clone(),
outcome: AaveUpdateOutcome::Advanced {
from_block: report.from_block,
to_block: report.to_block,
chunks_committed: report.chunks_committed,
total_events_applied: report.total_events_applied,
},
});
cleanup_zero_balance_positions(&database_path, market.id)?;
if args.enable_backup {
let backup = backup_for_block(&database_path, report.to_block)?;
tracing::info!(
chain_id = chain,
to_block = report.to_block,
backup = %backup.display(),
"created Aave database backup at block"
);
}
}
Err(RunError::Cancelled) => {
entries.push(AaveUpdateEntry {
chain_id: chain,
market_id: market.id,
market_name: market.name.clone(),
outcome: AaveUpdateOutcome::Cancelled,
});
return Ok(AaveReport::Updated { entries });
}
Err(err) => return Err(CliError::AaveUpdate(err)),
}
}
}
Ok(AaveReport::Updated { entries })
}
struct ResetLock {
path: std::path::PathBuf,
_file: std::fs::File,
}
impl ResetLock {
fn acquire(database_path: &std::path::Path, market_id: i64) -> Result<Self, CliError> {
use std::io::Write as _;
let mut path = database_path.to_path_buf();
let stem = database_path
.file_name()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_default();
path.set_file_name(format!("{stem}.aave-reset.lock"));
let file = std::fs::OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(&path)
.map_err(CliError::Io)?;
file.try_lock().map_err(|err| match err {
std::fs::TryLockError::WouldBlock => CliError::AaveMarketMidUpdate {
market_id,
lock_path: path.display().to_string(),
},
std::fs::TryLockError::Error(err) => CliError::Io(err),
})?;
let mut file = file;
file.set_len(0).map_err(CliError::Io)?;
writeln!(file, "{}", std::process::id()).map_err(CliError::Io)?;
Ok(Self { path, _file: file })
}
}
impl Drop for ResetLock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
fn reset(
ctx: &CliContext<'_>,
_cancel: &CancelHandle,
chain_id: u64,
market_name: Option<&str>,
dry_run: bool,
) -> Result<AaveReport, CliError> {
let database_path = ctx.database_path()?.value;
let chain = i64::try_from(chain_id)
.map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
let deployment = resolve_aave_deployment(chain_id)?;
let market = {
let db = (DegenbotDb::open(&database_path)?).0;
let name = market_name.unwrap_or(deployment.market_name);
db.fetch_aave_market_by_name(chain, name)?
};
let Some(market) = market else {
let requested =
market_name.map_or_else(|| deployment.market_name.to_string(), ToString::to_string);
return Err(CliError::UnknownAaveMarket {
chain_id,
market_name: requested,
});
};
let counts: Vec<AaveMarketPurgeCount> = {
let db = (DegenbotDb::open(&database_path)?).0;
db.count_aave_market_rows(market.id)?
};
for count in &counts {
tracing::info!(
chain_id,
market_id = market.id,
table = count.table,
rows = count.rows,
dry_run,
"aave reset plan"
);
}
if dry_run {
return Ok(AaveReport::Reset {
chain_id,
market_id: market.id,
market_name: market.name,
counts,
dry_run: true,
reinit: None,
});
}
let _lock = ResetLock::acquire(&database_path, market.id)?;
let rpc_url = ctx.node_request_uri_for(chain_id)?.value;
let provider = match crate::pool::shared_runtime_block_on(async {
AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
}) {
Ok(Ok(provider)) => provider,
Ok(Err(err)) => return Err(CliError::AaveUpdate(RunError::from(err))),
Err(cli_err) => return Err(cli_err),
};
let (removed, facts) = {
let (db, _state) = DegenbotDb::open_for_writes(&database_path)?;
let mut guard = db.lock();
let tx = guard.transaction().map_err(DbError::from)?;
let removed = DegenbotDb::count_aave_market_rows_on_conn(&tx, market.id)?;
let facts = reset_market_to_cold_boot(
&tx,
market.id,
&deployment.pool_address_provider.to_checksum(None),
&deployment.gho_token_address.to_checksum(None),
&provider,
)
.map_err(CliError::AaveUpdate)?;
tx.commit().map_err(DbError::from)?;
(removed, facts)
};
tracing::info!(
chain_id,
market_id = market.id,
cursor = facts.last_update_block.unwrap_or_default(),
"reset Aave V3 market and re-stamped the cold-boot substrate"
);
Ok(AaveReport::Reset {
chain_id,
market_id: market.id,
market_name: market.name,
counts: removed,
dry_run: false,
reinit: Some(AaveReinit {
market_activated: facts.market_activated,
contract_row_present: facts.contract_row_present,
last_update_block: facts
.last_update_block
.map(|block| i64::try_from(block).unwrap_or(i64::MAX)),
}),
})
}
fn cleanup_zero_balance_positions(
database_path: &std::path::Path,
market_id: i64,
) -> Result<(), CliError> {
let (db, _state) = DegenbotDb::open_for_writes(database_path)?;
let mut guard = db.lock();
let tx = guard.transaction().map_err(DbError::from)?;
cleanup_zero_balance_positions_on_conn(&tx, market_id)?;
tx.commit().map_err(DbError::from)?;
Ok(())
}
fn backup_for_block(
database_path: &std::path::Path,
to_block: u64,
) -> Result<std::path::PathBuf, CliError> {
let stem = database_path
.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_default();
let mut backup = database_path.to_path_buf();
backup.set_file_name(format!("{stem}-{to_block}.db.bak"));
ops::backup_database(database_path, &backup)?;
Ok(backup)
}
fn position_show(
ctx: &CliContext<'_>,
raw_address: &str,
market: &str,
chain_id: u64,
) -> Result<AaveReport, CliError> {
let address: Address = raw_address
.parse()
.map_err(|_| CliError::InvalidAddress(raw_address.to_string()))?;
let user_address = address.to_checksum(None);
let chain = i64::try_from(chain_id)
.map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
let database_path = ctx.database_path()?.value;
let db = (DegenbotDb::open(&database_path)?).0;
let Some(market_row) = db.fetch_aave_market_by_name(chain, market)? else {
return Ok(AaveReport::PositionNoMarket {
market: market.to_string(),
chain_id,
});
};
let Some(user) = db.fetch_aave_user_by_address(market_row.id, &user_address)? else {
return Ok(AaveReport::PositionNoUser {
user_address,
market: market.to_string(),
chain_id,
});
};
let collateral = db
.fetch_aave_collateral_positions(user.id)?
.into_iter()
.map(|p| AavePositionLine {
symbol: p.underlying_symbol.unwrap_or_else(|| "Unknown".to_string()),
balance: p.balance,
})
.collect();
let debt = db
.fetch_aave_debt_positions(user.id)?
.into_iter()
.map(|p| AavePositionLine {
symbol: p.underlying_symbol.unwrap_or_else(|| "Unknown".to_string()),
balance: p.balance,
})
.collect();
Ok(AaveReport::Position {
user_address,
market: market.to_string(),
chain_id,
collateral,
debt,
})
}
#[cfg(test)]
mod tests {
#![expect(clippy::unwrap_used)]
use std::fs;
use std::path::PathBuf;
use std::time::{Duration, Instant};
use super::ResetLock;
use crate::error::CliError;
fn spawn_holder(db: &PathBuf, dir: &std::path::Path) -> std::process::Child {
let ready = dir.join("holder-ready");
let child = std::process::Command::new(std::env::current_exe().unwrap())
.args([
"--exact",
"aave::tests::reset_lock_holder_child",
"--ignored",
"--nocapture",
])
.env("RESET_LOCK_TEST_DB", db)
.env("RESET_LOCK_TEST_READY", &ready)
.spawn()
.unwrap();
let deadline = Instant::now() + Duration::from_secs(30);
while !ready.exists() {
assert!(
Instant::now() < deadline,
"holder child never armed the reset lock"
);
std::thread::sleep(Duration::from_millis(20));
}
child
}
#[test]
fn stale_lock_file_does_not_block_a_reset() {
let dir = tempfile::tempdir().unwrap();
let db = dir.path().join("degenbot.db");
let lock_path = dir.path().join("degenbot.db.aave-reset.lock");
fs::write(&lock_path, "999999999 dead holder\n").unwrap();
let lock = ResetLock::acquire(&db, 7).unwrap();
assert_eq!(
fs::read_to_string(&lock_path).unwrap().trim(),
std::process::id().to_string()
);
drop(lock);
assert!(!lock_path.exists());
}
#[test]
fn a_live_holder_blocks_until_it_releases() {
let dir = tempfile::tempdir().unwrap();
let db = dir.path().join("degenbot.db");
let holder = ResetLock::acquire(&db, 7).unwrap();
assert!(matches!(
ResetLock::acquire(&db, 7),
Err(CliError::AaveMarketMidUpdate { .. })
));
drop(holder);
ResetLock::acquire(&db, 7).unwrap();
}
#[test]
fn a_killed_holder_releases_the_reset_lock() {
let dir = tempfile::tempdir().unwrap();
let db = dir.path().join("degenbot.db");
let mut child = spawn_holder(&db, dir.path());
assert!(matches!(
ResetLock::acquire(&db, 7),
Err(CliError::AaveMarketMidUpdate { .. })
));
child.kill().unwrap();
child.wait().unwrap();
ResetLock::acquire(&db, 7).unwrap();
}
#[test]
#[ignore = "spawned as the fake holder by a_killed_holder_releases_the_reset_lock"]
fn reset_lock_holder_child() {
let db = PathBuf::from(std::env::var("RESET_LOCK_TEST_DB").unwrap());
let ready = PathBuf::from(std::env::var("RESET_LOCK_TEST_READY").unwrap());
let _lock = ResetLock::acquire(&db, 7).unwrap();
fs::write(&ready, b"armed").unwrap();
let deadline = Instant::now() + Duration::from_secs(120);
while Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(100));
}
}
}