1use std::sync::Arc;
22
23use alloy::primitives::{address, Address};
24use degenbot_aave::updater::verify::cleanup_zero_balance_positions_on_conn;
25use degenbot_aave::{
26 activate_aave_market, deactivate_aave_market, reset_market_to_cold_boot, run_aave_update,
27 NoProgress, RunError, RunSpec, VerifyPolicy,
28};
29use degenbot_db::{
30 aave_market_digest_for, ops, parse_completed_market_manifest, CompletedMarketDrive,
31 CompletedMarketManifest, DbError, DegenbotDb,
32};
33use degenbot_rpc::provider::AlloyProvider;
34
35use crate::block::{parse_to_block, resolve_to_block};
36use crate::cancel::CancelHandle;
37use crate::context::CliContext;
38use crate::error::CliError;
39use crate::prompt::{PromptPlan, Prompter};
40use crate::report::{
41 AavePositionLine, AaveReinit, AaveReport, AaveUpdateEntry, AaveUpdateOutcome, DeactivateOutcome,
42};
43use degenbot_db::AaveMarketPurgeCount;
44
45const RPC_MAX_RETRIES: u32 = 5;
48
49#[derive(Debug, Clone, Copy, PartialEq, Eq)]
51pub struct AaveDeployment {
52 pub chain_id: u64,
54 pub chain_label: &'static str,
56 pub market_name: &'static str,
60 pub pool_address_provider: Address,
62 pub gho_token_address: Address,
64}
65
66pub const AAVE_DEPLOYMENTS: &[AaveDeployment] = &[AaveDeployment {
68 chain_id: 1,
69 chain_label: "Ethereum",
70 market_name: "Aave Ethereum Market",
75 pool_address_provider: address!("2f39d218133AFaB8F2B819B1066c7E434Ad94E9e"),
76 gho_token_address: address!("40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f"),
77}];
78
79#[derive(Debug, Clone, PartialEq, Eq)]
81pub enum AaveCommand {
82 Activate {
84 chain_id: u64,
86 },
87 Deactivate {
89 chain_id: u64,
91 market_name: String,
93 },
94 Digest {
98 chain_id: u64,
100 market_name: Option<String>,
103 drive_manifest: Option<std::path::PathBuf>,
107 },
108 Update {
110 chunk_size: u64,
112 max_block_range: u64,
115 to_block: String,
117 verify_chunk: bool,
119 verify_all: bool,
121 verify_all_interval: u64,
123 stop_after_one_chunk: bool,
125 dry_run: bool,
127 enable_backup: bool,
129 },
130 Reset {
133 chain_id: u64,
135 market_name: Option<String>,
138 dry_run: bool,
140 },
141 PositionShow {
143 address: String,
145 market: String,
147 chain_id: u64,
149 },
150}
151
152impl AaveCommand {
153 #[must_use]
155 pub const fn prompt_plan(&self, _ctx: &CliContext<'_>) -> PromptPlan {
156 PromptPlan::None
157 }
158}
159
160pub fn resolve_aave_deployment(chain_id: u64) -> Result<&'static AaveDeployment, CliError> {
166 AAVE_DEPLOYMENTS
167 .iter()
168 .find(|d| d.chain_id == chain_id)
169 .ok_or_else(|| CliError::UnknownDeployment {
170 chain_id,
171 name: "ethereum_aave_v3".to_string(),
172 })
173}
174
175pub(crate) fn execute(
185 command: &AaveCommand,
186 ctx: &CliContext<'_>,
187 _prompter: &dyn Prompter,
188 cancel: &CancelHandle,
189) -> Result<AaveReport, CliError> {
190 match command {
191 AaveCommand::Activate { chain_id } => activate(ctx, *chain_id),
192 AaveCommand::Deactivate {
193 chain_id,
194 market_name,
195 } => deactivate(ctx, *chain_id, market_name),
196 AaveCommand::Digest {
197 chain_id,
198 market_name,
199 drive_manifest,
200 } => digest(
201 ctx,
202 *chain_id,
203 market_name.as_deref(),
204 drive_manifest.as_deref(),
205 ),
206 AaveCommand::Update {
207 chunk_size,
208 max_block_range,
209 to_block,
210 verify_chunk,
211 verify_all,
212 verify_all_interval,
213 stop_after_one_chunk,
214 dry_run,
215 enable_backup,
216 } => update(
217 ctx,
218 cancel,
219 &UpdateArgs {
220 chunk_size: *chunk_size,
221 max_block_range: *max_block_range,
222 to_block,
223 verify_chunk: *verify_chunk,
224 verify_all: *verify_all,
225 verify_all_interval: *verify_all_interval,
226 stop_after_one_chunk: *stop_after_one_chunk,
227 dry_run: *dry_run,
228 enable_backup: *enable_backup,
229 },
230 ),
231 AaveCommand::Reset {
232 chain_id,
233 market_name,
234 dry_run,
235 } => reset(ctx, cancel, *chain_id, market_name.as_deref(), *dry_run),
236 AaveCommand::PositionShow {
237 address,
238 market,
239 chain_id,
240 } => position_show(ctx, address, market, *chain_id),
241 }
242}
243
244fn activate(ctx: &CliContext<'_>, chain_id: u64) -> Result<AaveReport, CliError> {
246 let deployment = resolve_aave_deployment(chain_id)?;
247 let database_path = ctx.database_path()?.value;
248 let rpc_url = ctx.node_request_uri_for(chain_id)?.value;
249 let chain = i64::try_from(chain_id)
250 .map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
251 let result = match crate::pool::shared_runtime_block_on(async {
255 AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
256 }) {
257 Ok(Ok(provider)) => activate_aave_market(
258 &database_path,
259 chain,
260 &deployment.pool_address_provider.to_checksum(None),
261 &deployment.gho_token_address.to_checksum(None),
262 &provider,
263 ),
264 Ok(Err(err)) => Err(RunError::from(err)),
265 Err(cli_err) => return Err(cli_err),
266 }
267 .map_err(CliError::AaveUpdate)?;
268 tracing::info!(
269 chain_id,
270 market_id = result.market_id,
271 "activated Aave V3 market"
272 );
273 Ok(AaveReport::Activated {
274 chain_id,
275 chain_label: deployment.chain_label,
276 market_id: result.market_id,
277 market_name: result.market_name,
278 created: result.created,
279 })
280}
281
282fn deactivate(
284 ctx: &CliContext<'_>,
285 chain_id: u64,
286 market_name: &str,
287) -> Result<AaveReport, CliError> {
288 let database_path = ctx.database_path()?.value;
289 let chain = i64::try_from(chain_id)
290 .map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
291 let market = {
292 let db = (DegenbotDb::open(&database_path)?).0;
293 db.fetch_aave_market_by_name(chain, market_name)?
294 };
295 let Some(market) = market else {
296 return Ok(AaveReport::Deactivated {
297 chain_id,
298 market_id: None,
299 outcome: DeactivateOutcome::NoEntry,
300 });
301 };
302 if !market.active {
303 return Ok(AaveReport::Deactivated {
304 chain_id,
305 market_id: Some(market.id),
306 outcome: DeactivateOutcome::AlreadyDeactivated,
307 });
308 }
309 deactivate_aave_market(&database_path, market.id).map_err(CliError::AaveUpdate)?;
310 tracing::info!(
311 chain_id,
312 market_id = market.id,
313 "deactivated Aave V3 market"
314 );
315 Ok(AaveReport::Deactivated {
316 chain_id,
317 market_id: Some(market.id),
318 outcome: DeactivateOutcome::Deactivated,
319 })
320}
321
322fn digest(
324 ctx: &CliContext<'_>,
325 chain_id: u64,
326 market_name: Option<&str>,
327 drive_manifest: Option<&std::path::Path>,
328) -> Result<AaveReport, CliError> {
329 let database_path = ctx.database_path()?.value;
330 let chain = i64::try_from(chain_id)
331 .map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
332 let drive = drive_manifest.map(carried_drive).transpose()?;
333 let digest = {
334 let db = (DegenbotDb::open(&database_path)?).0;
337 let conn = db.lock();
338 aave_market_digest_for(&conn, Some(chain), market_name)?
339 };
340 Ok(AaveReport::Digest {
341 manifest: CompletedMarketManifest { digest, drive },
342 })
343}
344
345fn carried_drive(path: &std::path::Path) -> Result<CompletedMarketDrive, CliError> {
353 let raw = std::fs::read_to_string(path).map_err(CliError::Io)?;
354 let manifest = parse_completed_market_manifest(&raw)
355 .map_err(|error| CliError::InvalidArgument(format!("{}: {error}", path.display())))?;
356 manifest.drive.ok_or_else(|| {
357 CliError::InvalidArgument(format!("{} carries no market.drive block", path.display()))
358 })
359}
360
361#[expect(clippy::struct_excessive_bools)]
363struct UpdateArgs<'a> {
364 chunk_size: u64,
365 max_block_range: u64,
366 to_block: &'a str,
367 verify_chunk: bool,
368 verify_all: bool,
369 verify_all_interval: u64,
370 stop_after_one_chunk: bool,
371 dry_run: bool,
372 enable_backup: bool,
373}
374
375impl From<&UpdateArgs<'_>> for VerifyPolicy {
378 fn from(args: &UpdateArgs<'_>) -> Self {
379 Self {
380 verify_chunk: args.verify_chunk,
381 verify_all_interval: args.verify_all.then_some(args.verify_all_interval),
382 verify_all_at_completion: args.verify_all,
383 }
384 }
385}
386
387#[expect(clippy::too_many_lines)]
389fn update(
390 ctx: &CliContext<'_>,
391 cancel: &CancelHandle,
392 args: &UpdateArgs<'_>,
393) -> Result<AaveReport, CliError> {
394 let database_path = ctx.database_path()?.value;
395 crate::registrations::ensure_supported_registrations(&database_path)?;
399 let markets = {
400 let db = (DegenbotDb::open(&database_path)?).0;
401 db.fetch_active_aave_markets()?
402 };
403 if markets.is_empty() {
404 return Err(CliError::NoActiveAaveMarkets);
405 }
406 let spec = parse_to_block(args.to_block)?;
407 let max_chunks = if args.stop_after_one_chunk {
408 Some(1)
409 } else {
410 None
411 };
412 let mut entries: Vec<AaveUpdateEntry> = Vec::new();
413 let mut chain_ids: Vec<i64> = Vec::new();
414 for market in &markets {
415 if !chain_ids.contains(&market.chain_id) {
416 chain_ids.push(market.chain_id);
417 }
418 }
419 for chain in chain_ids {
420 if cancel.is_cancelled() {
421 break;
422 }
423 let chain_unsigned = u64::try_from(chain).map_err(|_| {
424 CliError::InvalidArgument(format!("market chain id {chain} is out of range"))
425 })?;
426 let rpc_url = ctx.node_request_uri_for(chain_unsigned)?.value;
427 let resolved = resolve_to_block(spec, &rpc_url)?;
428 for market in markets.iter().filter(|m| m.chain_id == chain) {
429 if cancel.is_cancelled() {
430 return Ok(AaveReport::Updated { entries });
431 }
432 let Some(last_update_block) = market.last_update_block else {
433 entries.push(AaveUpdateEntry {
434 chain_id: chain,
435 market_id: market.id,
436 market_name: market.name.clone(),
437 outcome: AaveUpdateOutcome::NeedsBootstrap,
438 });
439 continue;
440 };
441 if args.dry_run {
442 entries.push(AaveUpdateEntry {
443 chain_id: chain,
444 market_id: market.id,
445 market_name: market.name.clone(),
446 outcome: AaveUpdateOutcome::DryRun {
447 last_update_block,
448 to_block: resolved,
449 },
450 });
451 continue;
452 }
453 let run = match crate::pool::shared_runtime_block_on(async {
459 AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
460 }) {
461 Ok(Ok(provider)) => run_aave_update(
462 &database_path,
463 RunSpec {
464 chain_id: chain,
465 market_id: market.id,
466 to_block: resolved,
467 chunk_size: args.chunk_size,
468 max_block_range: args.max_block_range,
469 provider,
470 cancel: cancel.flag(),
471 progress: Arc::new(NoProgress),
472 verify: VerifyPolicy::from(args),
473 max_chunks,
474 },
475 ),
476 Ok(Err(err)) => Err(RunError::from(err)),
477 Err(cli_err) => return Err(cli_err),
478 };
479 match run {
480 Ok(report) => {
481 entries.push(AaveUpdateEntry {
482 chain_id: chain,
483 market_id: market.id,
484 market_name: market.name.clone(),
485 outcome: AaveUpdateOutcome::Advanced {
486 from_block: report.from_block,
487 to_block: report.to_block,
488 chunks_committed: report.chunks_committed,
489 total_events_applied: report.total_events_applied,
490 },
491 });
492 cleanup_zero_balance_positions(&database_path, market.id)?;
493 if args.enable_backup {
494 let backup = backup_for_block(&database_path, report.to_block)?;
495 tracing::info!(
496 chain_id = chain,
497 to_block = report.to_block,
498 backup = %backup.display(),
499 "created Aave database backup at block"
500 );
501 }
502 }
503 Err(RunError::Cancelled) => {
504 entries.push(AaveUpdateEntry {
505 chain_id: chain,
506 market_id: market.id,
507 market_name: market.name.clone(),
508 outcome: AaveUpdateOutcome::Cancelled,
509 });
510 return Ok(AaveReport::Updated { entries });
511 }
512 Err(err) => return Err(CliError::AaveUpdate(err)),
513 }
514 }
515 }
516 Ok(AaveReport::Updated { entries })
517}
518
519struct ResetLock {
533 path: std::path::PathBuf,
534 _file: std::fs::File,
538}
539
540impl ResetLock {
541 fn acquire(database_path: &std::path::Path, market_id: i64) -> Result<Self, CliError> {
543 use std::io::Write as _;
544
545 let mut path = database_path.to_path_buf();
546 let stem = database_path
547 .file_name()
548 .map(|s| s.to_string_lossy().into_owned())
549 .unwrap_or_default();
550 path.set_file_name(format!("{stem}.aave-reset.lock"));
551 let file = std::fs::OpenOptions::new()
555 .read(true)
556 .write(true)
557 .create(true)
558 .truncate(false)
559 .open(&path)
560 .map_err(CliError::Io)?;
561 file.try_lock().map_err(|err| match err {
562 std::fs::TryLockError::WouldBlock => CliError::AaveMarketMidUpdate {
563 market_id,
564 lock_path: path.display().to_string(),
565 },
566 std::fs::TryLockError::Error(err) => CliError::Io(err),
567 })?;
568 let mut file = file;
569 file.set_len(0).map_err(CliError::Io)?;
570 writeln!(file, "{}", std::process::id()).map_err(CliError::Io)?;
571 Ok(Self { path, _file: file })
572 }
573}
574
575impl Drop for ResetLock {
576 fn drop(&mut self) {
577 let _ = std::fs::remove_file(&self.path);
581 }
582}
583
584fn reset(
595 ctx: &CliContext<'_>,
596 _cancel: &CancelHandle,
597 chain_id: u64,
598 market_name: Option<&str>,
599 dry_run: bool,
600) -> Result<AaveReport, CliError> {
601 let database_path = ctx.database_path()?.value;
602 let chain = i64::try_from(chain_id)
603 .map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
604 let deployment = resolve_aave_deployment(chain_id)?;
609 let market = {
610 let db = (DegenbotDb::open(&database_path)?).0;
611 let name = market_name.unwrap_or(deployment.market_name);
613 db.fetch_aave_market_by_name(chain, name)?
614 };
615 let Some(market) = market else {
616 let requested =
617 market_name.map_or_else(|| deployment.market_name.to_string(), ToString::to_string);
618 return Err(CliError::UnknownAaveMarket {
619 chain_id,
620 market_name: requested,
621 });
622 };
623
624 let counts: Vec<AaveMarketPurgeCount> = {
627 let db = (DegenbotDb::open(&database_path)?).0;
628 db.count_aave_market_rows(market.id)?
629 };
630 for count in &counts {
631 tracing::info!(
632 chain_id,
633 market_id = market.id,
634 table = count.table,
635 rows = count.rows,
636 dry_run,
637 "aave reset plan"
638 );
639 }
640 if dry_run {
641 return Ok(AaveReport::Reset {
642 chain_id,
643 market_id: market.id,
644 market_name: market.name,
645 counts,
646 dry_run: true,
647 reinit: None,
648 });
649 }
650
651 let _lock = ResetLock::acquire(&database_path, market.id)?;
654
655 let rpc_url = ctx.node_request_uri_for(chain_id)?.value;
660 let provider = match crate::pool::shared_runtime_block_on(async {
661 AlloyProvider::new(&rpc_url, RPC_MAX_RETRIES).await
662 }) {
663 Ok(Ok(provider)) => provider,
664 Ok(Err(err)) => return Err(CliError::AaveUpdate(RunError::from(err))),
665 Err(cli_err) => return Err(cli_err),
666 };
667
668 let (removed, facts) = {
677 let (db, _state) = DegenbotDb::open_for_writes(&database_path)?;
678 let mut guard = db.lock();
679 let tx = guard.transaction().map_err(DbError::from)?;
680 let removed = DegenbotDb::count_aave_market_rows_on_conn(&tx, market.id)?;
681 let facts = reset_market_to_cold_boot(
682 &tx,
683 market.id,
684 &deployment.pool_address_provider.to_checksum(None),
685 &deployment.gho_token_address.to_checksum(None),
686 &provider,
687 )
688 .map_err(CliError::AaveUpdate)?;
689 tx.commit().map_err(DbError::from)?;
690 (removed, facts)
691 };
692 tracing::info!(
693 chain_id,
694 market_id = market.id,
695 cursor = facts.last_update_block.unwrap_or_default(),
696 "reset Aave V3 market and re-stamped the cold-boot substrate"
697 );
698 Ok(AaveReport::Reset {
699 chain_id,
700 market_id: market.id,
701 market_name: market.name,
702 counts: removed,
703 dry_run: false,
704 reinit: Some(AaveReinit {
705 market_activated: facts.market_activated,
706 contract_row_present: facts.contract_row_present,
707 last_update_block: facts
708 .last_update_block
709 .map(|block| i64::try_from(block).unwrap_or(i64::MAX)),
710 }),
711 })
712}
713
714fn cleanup_zero_balance_positions(
716 database_path: &std::path::Path,
717 market_id: i64,
718) -> Result<(), CliError> {
719 let (db, _state) = DegenbotDb::open_for_writes(database_path)?;
720 let mut guard = db.lock();
721 let tx = guard.transaction().map_err(DbError::from)?;
722 cleanup_zero_balance_positions_on_conn(&tx, market_id)?;
723 tx.commit().map_err(DbError::from)?;
724 Ok(())
725}
726
727fn backup_for_block(
729 database_path: &std::path::Path,
730 to_block: u64,
731) -> Result<std::path::PathBuf, CliError> {
732 let stem = database_path
733 .file_stem()
734 .map(|s| s.to_string_lossy().into_owned())
735 .unwrap_or_default();
736 let mut backup = database_path.to_path_buf();
737 backup.set_file_name(format!("{stem}-{to_block}.db.bak"));
738 ops::backup_database(database_path, &backup)?;
739 Ok(backup)
740}
741
742fn position_show(
744 ctx: &CliContext<'_>,
745 raw_address: &str,
746 market: &str,
747 chain_id: u64,
748) -> Result<AaveReport, CliError> {
749 let address: Address = raw_address
750 .parse()
751 .map_err(|_| CliError::InvalidAddress(raw_address.to_string()))?;
752 let user_address = address.to_checksum(None);
753 let chain = i64::try_from(chain_id)
754 .map_err(|_| CliError::InvalidArgument(format!("chain id {chain_id} is out of range")))?;
755 let database_path = ctx.database_path()?.value;
756 let db = (DegenbotDb::open(&database_path)?).0;
757 let Some(market_row) = db.fetch_aave_market_by_name(chain, market)? else {
758 return Ok(AaveReport::PositionNoMarket {
759 market: market.to_string(),
760 chain_id,
761 });
762 };
763 let Some(user) = db.fetch_aave_user_by_address(market_row.id, &user_address)? else {
764 return Ok(AaveReport::PositionNoUser {
765 user_address,
766 market: market.to_string(),
767 chain_id,
768 });
769 };
770 let collateral = db
771 .fetch_aave_collateral_positions(user.id)?
772 .into_iter()
773 .map(|p| AavePositionLine {
774 symbol: p.underlying_symbol.unwrap_or_else(|| "Unknown".to_string()),
775 balance: p.balance,
776 })
777 .collect();
778 let debt = db
779 .fetch_aave_debt_positions(user.id)?
780 .into_iter()
781 .map(|p| AavePositionLine {
782 symbol: p.underlying_symbol.unwrap_or_else(|| "Unknown".to_string()),
783 balance: p.balance,
784 })
785 .collect();
786 Ok(AaveReport::Position {
787 user_address,
788 market: market.to_string(),
789 chain_id,
790 collateral,
791 debt,
792 })
793}
794
795#[cfg(test)]
796mod tests {
797 #![expect(clippy::unwrap_used)]
798
799 use std::fs;
800 use std::path::PathBuf;
801 use std::time::{Duration, Instant};
802
803 use super::ResetLock;
804 use crate::error::CliError;
805
806 fn spawn_holder(db: &PathBuf, dir: &std::path::Path) -> std::process::Child {
809 let ready = dir.join("holder-ready");
810 let child = std::process::Command::new(std::env::current_exe().unwrap())
811 .args([
812 "--exact",
813 "aave::tests::reset_lock_holder_child",
814 "--ignored",
815 "--nocapture",
816 ])
817 .env("RESET_LOCK_TEST_DB", db)
818 .env("RESET_LOCK_TEST_READY", &ready)
819 .spawn()
820 .unwrap();
821 let deadline = Instant::now() + Duration::from_secs(30);
822 while !ready.exists() {
823 assert!(
824 Instant::now() < deadline,
825 "holder child never armed the reset lock"
826 );
827 std::thread::sleep(Duration::from_millis(20));
828 }
829 child
830 }
831
832 #[test]
833 fn stale_lock_file_does_not_block_a_reset() {
834 let dir = tempfile::tempdir().unwrap();
835 let db = dir.path().join("degenbot.db");
836 let lock_path = dir.path().join("degenbot.db.aave-reset.lock");
837 fs::write(&lock_path, "999999999 dead holder\n").unwrap();
839 let lock = ResetLock::acquire(&db, 7).unwrap();
840 assert_eq!(
842 fs::read_to_string(&lock_path).unwrap().trim(),
843 std::process::id().to_string()
844 );
845 drop(lock);
846 assert!(!lock_path.exists());
847 }
848
849 #[test]
850 fn a_live_holder_blocks_until_it_releases() {
851 let dir = tempfile::tempdir().unwrap();
852 let db = dir.path().join("degenbot.db");
853 let holder = ResetLock::acquire(&db, 7).unwrap();
854 assert!(matches!(
857 ResetLock::acquire(&db, 7),
858 Err(CliError::AaveMarketMidUpdate { .. })
859 ));
860 drop(holder);
861 ResetLock::acquire(&db, 7).unwrap();
862 }
863
864 #[test]
865 fn a_killed_holder_releases_the_reset_lock() {
866 let dir = tempfile::tempdir().unwrap();
867 let db = dir.path().join("degenbot.db");
868 let mut child = spawn_holder(&db, dir.path());
869 assert!(matches!(
871 ResetLock::acquire(&db, 7),
872 Err(CliError::AaveMarketMidUpdate { .. })
873 ));
874 child.kill().unwrap();
877 child.wait().unwrap();
878 ResetLock::acquire(&db, 7).unwrap();
879 }
880
881 #[test]
884 #[ignore = "spawned as the fake holder by a_killed_holder_releases_the_reset_lock"]
885 fn reset_lock_holder_child() {
886 let db = PathBuf::from(std::env::var("RESET_LOCK_TEST_DB").unwrap());
887 let ready = PathBuf::from(std::env::var("RESET_LOCK_TEST_READY").unwrap());
888 let _lock = ResetLock::acquire(&db, 7).unwrap();
889 fs::write(&ready, b"armed").unwrap();
890 let deadline = Instant::now() + Duration::from_secs(120);
893 while Instant::now() < deadline {
894 std::thread::sleep(Duration::from_millis(100));
895 }
896 }
897}