feat: update ethers to master and use cfg files instead of cli params

Author: gakonst

Cargo.lock

@@ -6,8 +6,7 @@ edition = "2018"
 
 [dependencies]
 anyhow = "1.0.32"
-ethers = { git = "https://github.com/gakonst/ethers-rs", branch = "nonce-manager" }
-# ethers = { git = "https://github.com/gakonst/ethers-rs" }
+ethers = { git = "https://github.com/gakonst/ethers-rs" }
 serde_json = "1.0.57"
 tokio = { version = "0.2.22", features = ["macros"] }
 
@@ -19,4 +18,4 @@ tracing-subscriber = "0.2.10"
 serde = "1.0.114"
 
 [build-dependencies]
-ethers = { git = "https://github.com/gakonst/ethers-rs", branch = "nonce-manager", features = ["abigen"] }
+ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }

Cargo.toml

@@ -72,24 +72,34 @@ impl<P: JsonRpcClient> Keeper<P> {
         let watcher = self.client.clone();
         let mut on_block = watcher.watch_blocks().await?.stream();
 
+        let mut file: Option<std::fs::File> = None;
         while on_block.next().await.is_some() {
-            let file = std::fs::OpenOptions::new()
-                .read(true)
-                .write(true)
-                .create(true)
-                .open(&fname)
-                .unwrap();
-
             let block_number = self.client.get_block_number().await?;
+
+            if block_number % 10 == 0.into() {
+                // on each new block we open a new file handler to dump our state.
+                // we should just have a database connection instead here...
+                file = Some(
+                    std::fs::OpenOptions::new()
+                        .read(true)
+                        .write(true)
+                        .create(true)
+                        .open(&fname)
+                        .unwrap(),
+                );
+            }
+
             let span = debug_span!("eloop", block = %block_number);
             let _enter = span.enter();
+
+            // run the logic for this block
             self.on_block(block_number).await?;
 
             // update our last block
             self.last_block = block_number;
 
-            // Log once every 20 blocks (~300s)
-            if block_number % 10 == 0.into() {
+            // Log once every 10 blocks
+            if let Some(file) = file.take() {
                 self.log(file);
             }
         }

src/keeper.rs

@@ -2,6 +2,7 @@ use ethers::prelude::*;
 use yield_liquidator::keeper::Keeper;
 
 use gumdrop::Options;
+use serde::Deserialize;
 use std::{convert::TryFrom, path::PathBuf, sync::Arc, time::Duration};
 use tracing::info;
 use tracing_subscriber::{filter::EnvFilter, fmt::Subscriber};
@@ -11,46 +12,17 @@ use tracing_subscriber::{filter::EnvFilter, fmt::Subscriber};
 struct Opts {
     help: bool,
 
-    #[options(
-        help = "the Yield controller's address",
-        default = "Cf699af73C25aC785E8Da72F4fA7872c86D43C15"
-    )]
-    controller: Address,
-
-    #[options(
-        help = "the Yield liquidation's address",
-        default = "b85F3d294edD2B76128cf918800BB21081f59223"
-    )]
-    liquidations: Address,
-
-    #[options(
-        help = "the DAI/WETH Uniswap V2 pair",
-        default = "6025b901C88e5739Cb4112fcf3F27E0264c5BdDe"
-    )]
-    uniswap: Address,
-
-    #[options(
-        help = "the address of your flashloan contract",
-        default = "FE35d86cb5b6c0273fAC070Cc40aFeA77574cEF0"
-    )]
-    flashloan: Address,
-
-    #[options(
-        help = "the address of the Multicall contract (optional for any of the deployed testnets)"
-    )]
-    multicall: Option<Address>,
+    #[options(help = "path to json file with the contract addresses")]
+    config: PathBuf,
 
     #[options(
-        help = "the Ethereum node HTTP endpoint",
+        help = "the Ethereum node endpoint (HTTP or WS)",
         default = "http://localhost:8545"
     )]
     url: String,
 
-    #[options(
-        help = "your private key",
-        default = "8b6e036da61e5ac4874a770d7258583cd1b373798e740deaff4015fea80294b0"
-    )]
-    private_key: String,
+    #[options(help = "path to your private key")]
+    private_key: PathBuf,
 
     #[options(help = "polling interval (ms)", default = "1000")]
     interval: u64,
@@ -62,6 +34,15 @@ struct Opts {
     min_profit: U256,
 }
 
+#[derive(Deserialize)]
+struct Config {
+    controller: Address,
+    liquidations: Address,
+    uniswap: Address,
+    flashloan: Address,
+    multicall: Option<Address>,
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     Subscriber::builder()
@@ -83,19 +64,25 @@ async fn main() -> anyhow::Result<()> {
 }
 
 async fn run<P: JsonRpcClient>(opts: Opts, provider: Provider<P>) -> anyhow::Result<()> {
-    let wallet: Wallet = opts.private_key.parse()?;
+    info!("Starting Yield Liquidator.");
+    let wallet: Wallet = std::fs::read_to_string(opts.private_key)?.parse()?;
     let client = wallet
         .connect(provider)
-        .interval(Duration::from_millis(opts.interval));
+        .interval(Duration::from_millis(opts.interval))
+        // enable the nonce-manager so that we can send multiple transactions in a row
+        // without waiting for them to be included in the mempool
+        .with_nonce_manager();
     let client = Arc::new(client);
-    info!("Starting Yield Liquidator.");
-    info!("Node: {}", opts.url);
     info!("Profits will be sent to {:?}", client.address());
-    info!("Controller: {:?}", opts.controller);
-    info!("Liquidations: {:?}", opts.liquidations);
-    info!("Uniswap: {:?}", opts.uniswap);
-    info!("Multicall: {:?}", opts.multicall);
-    info!("FlashLiquidator {:?}", opts.flashloan);
+
+    info!("Node: {}", opts.url);
+
+    let cfg: Config = serde_json::from_reader(std::fs::File::open(opts.config)?)?;
+    info!("Controller: {:?}", cfg.controller);
+    info!("Liquidations: {:?}", cfg.liquidations);
+    info!("Uniswap: {:?}", cfg.uniswap);
+    info!("Multicall: {:?}", cfg.multicall);
+    info!("FlashLiquidator {:?}", cfg.flashloan);
     info!("Persistent data will be stored at: {:?}", opts.file);
 
     let file = std::fs::OpenOptions::new()
@@ -108,11 +95,11 @@ async fn run<P: JsonRpcClient>(opts: Opts, provider: Provider<P>) -> anyhow::Res
 
     let mut keeper = Keeper::new(
         client,
-        opts.controller,
-        opts.liquidations,
-        opts.uniswap,
-        opts.flashloan,
-        opts.multicall,
+        cfg.controller,
+        cfg.liquidations,
+        cfg.uniswap,
+        cfg.flashloan,
+        cfg.multicall,
         opts.min_profit,
         state,
     )