Rollback

src/common/nonce_cache.rs

@@ -15,6 +15,8 @@ pub struct NonceInfo {
     pub nonce_account: Option<Pubkey>,
     /// Current nonce value
     pub current_nonce: Hash,
+    /// Next available time (Unix timestamp in seconds)
+    pub next_buy_time: i64,
     /// Whether it has been used
     pub used: bool,
 }
@@ -37,6 +39,7 @@ impl NonceCache {
                     nonce_info: Mutex::new(NonceInfo {
                         nonce_account: None,
                         current_nonce: Hash::default(),
+                        next_buy_time: 0,
                         used: false,
                     }),
                 })
@@ -47,7 +50,7 @@ impl NonceCache {
     /// Initialize nonce information
     pub fn init(&self, nonce_account_str: Option<String>) {
         let nonce_account = nonce_account_str.and_then(|s| Pubkey::from_str(&s).ok());
-        self.update_nonce_info_partial(nonce_account, None, Some(false));
+        self.update_nonce_info_partial(nonce_account, None, None, Some(false));
     }
 
     /// Get a copy of NonceInfo
@@ -56,6 +59,7 @@ impl NonceCache {
         NonceInfo {
             nonce_account: nonce_info.nonce_account,
             current_nonce: nonce_info.current_nonce,
+            next_buy_time: nonce_info.next_buy_time,
             used: nonce_info.used,
         }
     }
@@ -65,6 +69,7 @@ impl NonceCache {
         &self,
         nonce_account: Option<Pubkey>,
         current_nonce: Option<Hash>,
+        next_buy_time: Option<i64>,
         used: Option<bool>,
     ) {
         let mut current = self.nonce_info.lock();
@@ -78,6 +83,10 @@ impl NonceCache {
             current.current_nonce = nonce;
         }
 
+        if let Some(time) = next_buy_time {
+            current.next_buy_time = time;
+        }
+
         if let Some(u) = used {
             current.used = u;
         }
@@ -85,7 +94,7 @@ impl NonceCache {
 
     /// Mark nonce as used
     pub fn mark_used(&self) {
-        self.update_nonce_info_partial(None, None, Some(true));
+        self.update_nonce_info_partial(None, None, None, Some(true));
     }
 
     /// Fetch nonce information using RPC
@@ -100,7 +109,12 @@ impl NonceCache {
                         let blockhash = data.durable_nonce.as_hash();
                         let old_nonce_info = self.get_nonce_info();
                         if old_nonce_info.current_nonce != *blockhash {
-                            self.update_nonce_info_partial(None, Some(*blockhash), Some(false));
+                            self.update_nonce_info_partial(
+                                None,
+                                Some(*blockhash),
+                                None,
+                                Some(false),
+                            );
                         }
                     }
                 }

src/common/types.rs

@@ -1,2 +1,80 @@
+use std::sync::Arc;
+
+use crate::{
+    constants::trade::trade::{
+        DEFAULT_BUY_TIP_FEE, DEFAULT_RPC_UNIT_LIMIT, DEFAULT_RPC_UNIT_PRICE, DEFAULT_SELL_TIP_FEE,
+        DEFAULT_TIP_UNIT_LIMIT, DEFAULT_TIP_UNIT_PRICE,
+    },
+    swqos::{SwqosClient, SwqosConfig},
+};
+use serde::Deserialize;
+use solana_client::rpc_client::RpcClient;
+use solana_sdk::{commitment_config::CommitmentConfig, signature::Keypair};
+
+#[derive(Debug, Clone)]
+pub struct TradeConfig {
+    pub rpc_url: String,
+    pub swqos_configs: Vec<SwqosConfig>,
+    pub priority_fee: PriorityFee,
+    pub commitment: CommitmentConfig,
+}
+
+impl TradeConfig {
+    pub fn new(
+        rpc_url: String,
+        swqos_configs: Vec<SwqosConfig>,
+        priority_fee: PriorityFee,
+        commitment: CommitmentConfig,
+    ) -> Self {
+        Self { rpc_url, swqos_configs, priority_fee, commitment }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+pub struct PriorityFee {
+    pub tip_unit_limit: u32,
+    pub tip_unit_price: u64,
+    pub rpc_unit_limit: u32,
+    pub rpc_unit_price: u64,
+    // Matches the order of swqos
+    pub buy_tip_fees: Vec<f64>,
+    // Matches the order of swqos
+    pub sell_tip_fees: Vec<f64>,
+}
+
+impl Default for PriorityFee {
+    fn default() -> Self {
+        Self {
+            tip_unit_limit: DEFAULT_TIP_UNIT_LIMIT,
+            tip_unit_price: DEFAULT_TIP_UNIT_PRICE,
+            rpc_unit_limit: DEFAULT_RPC_UNIT_LIMIT,
+            rpc_unit_price: DEFAULT_RPC_UNIT_PRICE,
+            // Matches the order of swqos
+            buy_tip_fees: vec![DEFAULT_BUY_TIP_FEE],
+            // Matches the order of swqos
+            sell_tip_fees: vec![DEFAULT_SELL_TIP_FEE],
+        }
+    }
+}
+
 pub type SolanaRpcClient = solana_client::nonblocking::rpc_client::RpcClient;
+
+pub struct MethodArgs {
+    pub payer: Arc<Keypair>,
+    pub rpc: Arc<RpcClient>,
+    pub nonblocking_rpc: Arc<SolanaRpcClient>,
+    pub jito_client: Arc<SwqosClient>,
+}
+
+impl MethodArgs {
+    pub fn new(
+        payer: Arc<Keypair>,
+        rpc: Arc<RpcClient>,
+        nonblocking_rpc: Arc<SolanaRpcClient>,
+        jito_client: Arc<SwqosClient>,
+    ) -> Self {
+        Self { payer, rpc, nonblocking_rpc, jito_client }
+    }
+}
+
 pub type AnyResult<T> = anyhow::Result<T>;