feat: Fetch all deployments from registry

Author: petarvujovic98

bots/README.md

@@ -26,20 +26,21 @@ Running the Bot:
 
 ```bash
 liquidator-service \
-    --markets market1.testnet \
+    --registries registry1.testnet --registries registry2.testnet \
     --signer-key ed25519:\<YOUR_PRIVATE_KEY_HERE> \
     --signer-account liquidator.testnet \
     --asset usdc.testnet \
     --swap rhea-swap \
     --network testnet \
     --timeout 60 \
     --concurrency 10 \
-    --interval 600
+    --interval 600 \
+    --registry-refresh-interval 3600
 ```
 
 Arguments:
 
-- `--markets`: A list of markets to monitor for liquidations (e.g., templar-market1.testnet).
+- `--registries`: A list of registries to query markets from which will be monitored for liquidations (e.g., templar-registry1.testnet).
 - `--signer-key`: The private key of the signer account used to sign transactions.
 - `--signer-account`: The NEAR account that will perform the liquidations (e.g., templar-liquidator.testnet).
 - `--asset`: The asset to liquidate NEP-141 token account used for repayments (e.g., usdc.testnet).
@@ -48,10 +49,12 @@ Arguments:
 - `--timeout`: The timeout for RPC calls in seconds (default is 60 seconds).
 - `--concurrency`: The number of concurrent liquidation attempts (default is 10).
 - `--interval`: The interval in seconds for the service to check for liquidatable positions (default is 600 seconds).
+- `--registry-refresh-interval`: The interval in seconds for the service to check for new markets on the registries (default is 3600 seconds - 1 hour).
 
 How it works:
 
-1. The bot initializes a Liquidator object for each market specified in the `--markets` argument.
+1. The bot fetches all deployments for each registry specified in the `--registryes` argument.
+1. The bot initializes a Liquidator object for each market fetched.
 1. It continuously checks the status of borrowers in each market.
 1. If a borrower is found to be liquidatable, it calculates the liquidation amount based on the borrower's collateral and debt.
 1. It sends an `ft_transfer_call` RPC call to the smart contract to trigger the liquidation process.
@@ -66,7 +69,7 @@ Liquidation Logic:
 The liquidation logic is encapsulated within the `Liquidator` object, which is responsible for:
 
 - Checking a borrower's status to determine if they are below the required collateralization ratio.
-- Calculating the liquidation amount based on the borrower's collateral and debt. (This calculation should be implemented by the liquidator according to their specific strategy or requirements.)
+- Calculating the liquidation amount based on the borrower's collateral and debt.
 
 ```rust
 #[instrument(skip(self), level = "debug")]
@@ -76,17 +79,7 @@ async fn liquidation_amount(
     oracle_response: &OracleResponse,
     configuration: MarketConfiguration,
 ) -> LiquidatorResult<(U128, U128)> {
-    // TODO: Calculate optimal liquidation amount
-    // For purposes of this example implementation we will just use the minimum acceptable
-    // liquidation amount.
-    // Costs to take into account here are:
-    //  - Gas fees
-    //  - Price impact
-    //  - Slippage
-    // All of this would be used in calculating both the optimal liquidation amount and wether to
-    // perform full or partial liquidation
     let borrow_asset = &configuration.borrow_asset;
-    let collateral_asset = &configuration.collateral_asset;
     let price_pair = configuration
         .price_oracle_configuration
         .create_price_pair(oracle_response)?;
@@ -111,20 +104,32 @@ async fn liquidation_amount(
         )
         .await
         .map_err(LiquidatorError::QuoteError)?;
-    let _quote_after_liquidate = self
-        .swap
-        .quote(
-            // TODO: Enable multitoken swaps
-            &collateral_asset.contract_id(),
-            &self.asset,
-            position.collateral_asset_deposit.into(),
-        )
-        .await
-        .map_err(LiquidatorError::QuoteError)?;
     Ok((quote_to_liquidate, min_liquidation_amount.into()))
 }
 ```
 
+- Deciding on whether the liquidation should happen or not (This calculation should be implemented by the liquidator according to their specific strategy or requirements.)
+
+```rust
+#[instrument(skip(self), level = "debug")]
+pub async fn should_liquidate(
+    &self,
+    swap_amount: U128,
+    liquidation_amount: U128,
+) -> LiquidatorResult<bool> {
+    // TODO: Calculate optimal liquidation amount
+    // For purposes of this example implementation we will just use the minimum acceptable
+    // liquidation amount.
+    // Costs to take into account here are:
+    //  - Gas fees
+    //  - Price impact
+    //  - Slippage
+    // All of this would be used in calculating both the optimal liquidation amount and wether to
+    // perform full or partial liquidation
+    Ok(true)
+}
+```
+
 - Sending the `ft_transfer_call` RPC call to the borrow asset contract to trigger liquidation.
 - Handling errors and retries for failed liquidation attempts.
 - Logging the results of each liquidation attempt for monitoring and debugging purposes.
@@ -172,6 +177,67 @@ async fn get_oracle_prices(
 
 The liquidator will fetch the price data from the oracle contract in order to execute the liquidation and gauge whether the liquidation is profitable.
 
+### Fetching deployed markets
+
+```rust
+#[instrument(skip(client), level = "debug")]
+pub async fn list_deployments(
+    client: &JsonRpcClient,
+    registry: AccountId,
+    count: Option<u32>,
+    offset: Option<u32>,
+) -> RpcResult<Vec<AccountId>> {
+    let mut all_deployments = Vec::new();
+    let page_size = 500;
+    let mut current_offset = 0;
+
+    loop {
+        let params = json!({
+            "offset": current_offset,
+            "count": page_size,
+        });
+
+        let page =
+            view::<Vec<AccountId>>(client, registry.clone(), "list_deployments", params).await?;
+
+        let fetched = page.len();
+
+        if fetched == 0 {
+            break;
+        }
+
+        all_deployments.extend(page);
+        current_offset += fetched;
+
+        if fetched < page_size {
+            break;
+        }
+    }
+
+    Ok(all_deployments)
+}
+
+#[instrument(skip(client), level = "debug")]
+pub async fn list_all_deployments(
+    client: JsonRpcClient,
+    registries: Vec<AccountId>,
+    concurrency: usize,
+) -> RpcResult<Vec<AccountId>> {
+    let all_markets: Vec<AccountId> = futures::stream::iter(registries)
+        .map(|registry| {
+            let client = client.clone();
+            async move { list_deployments(&client, registry, None, None).await }
+        })
+        .buffer_unordered(concurrency)
+        .try_concat()
+        .await?;
+
+    Ok(all_markets)
+}
+```
+
+The liquidator will periodically fetch all registries for all of their deployments (markets).
+
 ### Getting the borrow positions for a market
 
 ```rust

bots/src/bin/liquidator-bot.rs

@@ -1,11 +1,78 @@
-use std::time::Duration;
+use std::{
+    collections::HashMap,
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use clap::Parser;
-use templar_bots::liquidator::{setup_liquidators, Args, LiquidatorResult};
+use futures::{StreamExt, TryStreamExt};
+use near_crypto::InMemorySigner;
+use near_jsonrpc_client::JsonRpcClient;
+use near_sdk::{serde_json::json, AccountId};
+use templar_bots::{
+    liquidator::{Args, Liquidator, LiquidatorError, LiquidatorResult},
+    near::{view, RpcResult},
+    swap::{RheaSwap, SwapType},
+};
 use tokio::time::sleep;
-use tracing::info;
+use tracing::{info, instrument};
 use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 
+#[instrument(skip(client), level = "debug")]
+pub async fn list_deployments(
+    client: &JsonRpcClient,
+    registry: AccountId,
+    count: Option<u32>,
+    offset: Option<u32>,
+) -> RpcResult<Vec<AccountId>> {
+    let mut all_deployments = Vec::new();
+    let page_size = 500;
+    let mut current_offset = 0;
+
+    loop {
+        let params = json!({
+            "offset": current_offset,
+            "count": page_size,
+        });
+
+        let page =
+            view::<Vec<AccountId>>(client, registry.clone(), "list_deployments", params).await?;
+
+        let fetched = page.len();
+
+        if fetched == 0 {
+            break;
+        }
+
+        all_deployments.extend(page);
+        current_offset += fetched;
+
+        if fetched < page_size {
+            break;
+        }
+    }
+
+    Ok(all_deployments)
+}
+
+#[instrument(skip(client), level = "debug")]
+pub async fn list_all_deployments(
+    client: JsonRpcClient,
+    registries: Vec<AccountId>,
+    concurrency: usize,
+) -> RpcResult<Vec<AccountId>> {
+    let all_markets: Vec<AccountId> = futures::stream::iter(registries)
+        .map(|registry| {
+            let client = client.clone();
+            async move { list_deployments(&client, registry, None, None).await }
+        })
+        .buffer_unordered(concurrency)
+        .try_concat()
+        .await?;
+
+    Ok(all_markets)
+}
+
 #[tokio::main]
 async fn main() -> LiquidatorResult {
     tracing_subscriber::registry()
@@ -14,11 +81,53 @@ async fn main() -> LiquidatorResult {
         .init();
 
     let args = Args::parse();
+    let client = JsonRpcClient::connect(args.network.rpc_url());
+    let signer = Arc::new(InMemorySigner::from_secret_key(
+        args.signer_account.clone(),
+        args.signer_key.clone(),
+    ));
+    let swap = match args.swap {
+        SwapType::RheaSwap => Arc::new(RheaSwap::new(
+            args.swap.account_id(args.network),
+            client.clone(),
+            signer.clone(),
+        )),
+    };
+    let asset = Arc::new(args.asset);
 
-    let liquidators = setup_liquidators(&args)?;
+    let registry_refresh_interval = Duration::from_secs(args.registry_refresh_interval);
+    let mut next_refresh = Instant::now();
+    let mut markets = HashMap::<AccountId, Liquidator<_>>::new();
 
     loop {
-        for liquidator in &liquidators {
+        if Instant::now() >= next_refresh {
+            info!("Refreshing registry deployments");
+            let all_markets =
+                list_all_deployments(client.clone(), args.registries.clone(), args.concurrency)
+                    .await
+                    .map_err(LiquidatorError::ListDeploymentsError)?;
+            info!("Found {} deployments", all_markets.len());
+            markets = all_markets
+                .into_iter()
+                .map(|market| {
+                    let liquidator = Liquidator::new(
+                        // All clones are Arcs so this is cheap
+                        client.clone(),
+                        signer.clone(),
+                        asset.clone(),
+                        // This is the only true clone
+                        market.clone(),
+                        swap.clone(),
+                        args.timeout,
+                    );
+                    (market, liquidator)
+                })
+                .collect();
+            next_refresh = Instant::now() + registry_refresh_interval;
+        }
+
+        for (market, liquidator) in &markets {
+            info!("Running liquidations for market: {}", market);
             liquidator.run_liquidations(args.concurrency).await?;
         }