feat: Add near-intents support to liquidator bot

Author: petarvujovic98

Cargo.lock

@@ -27,6 +27,7 @@ near-sdk = { version = "5.7", features = ["unstable"] }
 near-sdk-contract-tools = { git = "https://github.com/near/near-sdk-contract-tools", branch = "140-nep-245-multitoken-component" }
 near-workspaces = { version = "0.16", features = ["unstable"] }
 primitive-types = { version = "0.10.1" }
+reqwest = "0.12.12"
 rstest = { version = "0.24" }
 schemars = { version = "0.8" }
 templar-common = { path = "./common" }

Cargo.toml

@@ -24,6 +24,7 @@ near-jsonrpc-client = { workspace = true }
 near-jsonrpc-primitives = { workspace = true }
 near-primitives = { workspace = true }
 near-sdk = { workspace = true }
+reqwest = { workspace = true }
 templar-common = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }

bots/Cargo.toml

@@ -12,7 +12,7 @@ use near_sdk::{serde_json::json, AccountId};
 use templar_bots::{
     liquidator::{Args, Liquidator, LiquidatorError, LiquidatorResult},
     near::{view, RpcResult},
-    swap::{RheaSwap, SwapType},
+    swap::{IntentsSwap, RheaSwap, Swap, SwapType},
 };
 use tokio::time::sleep;
 use tracing::{info, instrument};
@@ -73,30 +73,17 @@ pub async fn list_all_deployments(
     Ok(all_markets)
 }
 
-#[tokio::main]
-async fn main() -> LiquidatorResult {
-    tracing_subscriber::registry()
-        .with(fmt::layer())
-        .with(EnvFilter::from_default_env())
-        .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);
-
+#[instrument(skip(client, asset, swap), level = "debug")]
+async fn run_bot<S: Swap>(
+    client: JsonRpcClient,
+    signer: Arc<InMemorySigner>,
+    asset: Arc<AccountId>,
+    swap: Arc<S>,
+    args: &Args,
+) -> LiquidatorResult {
     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 {
@@ -139,3 +126,42 @@ async fn main() -> LiquidatorResult {
         sleep(Duration::from_secs(args.interval)).await;
     }
 }
+
+#[tokio::main]
+async fn main() -> LiquidatorResult {
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .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 asset = Arc::new(args.asset.clone());
+
+    match args.swap {
+        SwapType::RheaSwap => {
+            run_bot(
+                client.clone(),
+                signer.clone(),
+                asset,
+                Arc::new(RheaSwap::new(args.network, client, signer)),
+                &args,
+            )
+            .await
+        }
+        SwapType::NearIntents => {
+            run_bot(
+                client.clone(),
+                signer.clone(),
+                asset,
+                Arc::new(IntentsSwap::new(args.network, client, signer)),
+                &args,
+            )
+            .await
+        }
+    }
+}

bots/src/bin/liquidator-bot.rs

@@ -23,7 +23,7 @@ use tracing::{error, info, instrument, warn};
 
 use crate::{
     near::{get_access_key_data, send_tx, serialize_and_encode, view, RpcError},
-    swap::{Swap, SwapType},
+    swap::{QuoteOutput, Swap, SwapType},
     BorrowPositions, Network, DEFAULT_GAS,
 };
 
@@ -240,24 +240,27 @@ impl<S: Swap> Liquidator<S> {
 
         let available = self.get_asset_balance(self.asset.as_ref().clone()).await?;
 
-        if available < swap_amount {
-            warn!("Insufficient asset balance for liquidation: {available:?} < {swap_amount:?}");
+        if available < swap_amount.to_u128() {
+            warn!(
+                "Insufficient asset balance for liquidation: {available:?} < {:?}",
+                swap_amount.to_u128()
+            );
             return Ok(());
         }
 
         // Implement this function based on your liquidation strategy
         if !self
-            .should_liquidate(swap_amount, liquidation_amount)
+            .should_liquidate(&swap_amount, liquidation_amount)
             .await?
         {
             info!("Skipping liquidation due to insufficient conditions");
             return Ok(());
         }
 
-        if swap_amount > 0.into() {
+        if swap_amount.to_u128() > 0.into() {
             match self
                 .swap
-                .swap(&self.asset, &borrow_asset, swap_amount)
+                .swap(&self.asset, &borrow_asset, swap_amount.to_u128())
                 .await
             {
                 Ok(_) => {
@@ -450,10 +453,10 @@ impl<S: Swap> Liquidator<S> {
         Ok(())
     }
 
-    #[instrument(skip(self), level = "debug")]
+    #[instrument(skip(self, swap_amount), level = "debug", fields(swap_amount = ?swap_amount.to_u128()))]
     pub async fn should_liquidate(
         &self,
-        swap_amount: U128,
+        swap_amount: &S::QuoteOutput,
         liquidation_amount: U128,
     ) -> LiquidatorResult<bool> {
         // TODO: Calculate optimal liquidation amount

bots/src/liquidator.rs

@@ -49,6 +49,18 @@ pub enum RpcError {
     /// No outcome for transaction
     #[error("No outcome for transaction: {0}")]
     NoOutcome(String),
+    /// Error sending request to Solver RPC
+    #[error("Error sending request to Solver RPC: {0}")]
+    SolverRequestError(reqwest::Error),
+    /// Error deserializing response from Solver RPC
+    #[error("Error deserializing response from Solver RPC: {0}")]
+    SolverResponseDeserialization(reqwest::Error),
+    /// No quote hash received from Solver RPC
+    #[error("No quote hash received from Solver RPC")]
+    NoQuoteHashReceived,
+    /// Error getting system time
+    #[error("Error getting system time: {0}")]
+    SystemTimeError(#[from] std::time::SystemTimeError),
 }
 
 pub type RpcResult<T = ()> = Result<T, RpcError>;