Add cache_headers

Author: gemcoder21

crates/gem_jsonrpc/src/rpc.rs

@@ -10,8 +10,6 @@ use std::{
     sync::Arc,
 };
 
-pub const X_CACHE_TTL: &str = "x-gem-cache-ttl";
-
 pub type RpcResponse = Response;
 
 pub trait RpcClientError: Error + Send + Sync + 'static + Display + Sized {
@@ -52,7 +50,7 @@ impl Target {
             self.headers = Some(HashMap::new());
         }
         if let Some(headers) = self.headers.as_mut() {
-            headers.insert(X_CACHE_TTL.into(), ttl.to_string());
+            headers.insert(gem_client::X_CACHE_TTL.into(), ttl.to_string());
         }
         self
     }

crates/swapper/src/cache.rs

@@ -3,6 +3,10 @@ use std::collections::HashMap;
 
 pub(crate) const STATIC_READ_CACHE_TTL_SECONDS: u64 = 30 * primitives::duration::DAY.as_secs();
 
+pub(crate) fn cache_headers(ttl_seconds: u64) -> HashMap<String, String> {
+    HashMap::from([(X_CACHE_TTL.to_string(), ttl_seconds.to_string())])
+}
+
 pub(crate) fn static_read_cache_headers() -> HashMap<String, String> {
-    HashMap::from([(X_CACHE_TTL.to_string(), STATIC_READ_CACHE_TTL_SECONDS.to_string())])
+    cache_headers(STATIC_READ_CACHE_TTL_SECONDS)
 }

crates/swapper/src/lib.rs

@@ -35,7 +35,7 @@ pub mod uniswap;
 
 use number_formatter::BigNumberFormatter;
 
-pub(crate) use cache::{STATIC_READ_CACHE_TTL_SECONDS, static_read_cache_headers};
+pub(crate) use cache::{STATIC_READ_CACHE_TTL_SECONDS, cache_headers, static_read_cache_headers};
 
 /// Converts a human-readable amount string to base units value.
 pub fn amount_to_value(token: &str, decimals: u32) -> Option<String> {

crates/swapper/src/stonfi/client.rs

@@ -10,7 +10,7 @@ use gem_ton::{
 use num_bigint::BigUint;
 use num_traits::{Num, ToPrimitive};
 use primitives::Address as PrimitiveAddress;
-use std::{collections::HashMap, fmt::Debug, str::FromStr};
+use std::{fmt::Debug, str::FromStr};
 
 const GET_WALLET_ADDRESS_METHOD: &str = "get_wallet_address";
 const GET_POOL_ADDRESS_METHOD: &str = "get_pool_address";
@@ -84,17 +84,21 @@ where
     }
 
     async fn run_get_method(&self, address: &str, method: &str, stack: Vec<StackArg>) -> Result<RunGetMethodResult, SwapperError> {
-        self.run_get_method_with_headers(address, method, stack, HashMap::new()).await
+        let result = self
+            .ton_client
+            .run_get_method(address, method, stack)
+            .await
+            .map_err(|err| SwapperError::ComputeQuoteError(err.to_string()))?;
+        if result.exit_code != 0 {
+            return Err(SwapperError::ComputeQuoteError(format!("TON get-method {method} exit code {}", result.exit_code)));
+        }
+        Ok(result)
     }
 
     async fn run_static_get_method(&self, address: &str, method: &str, stack: Vec<StackArg>) -> Result<RunGetMethodResult, SwapperError> {
-        self.run_get_method_with_headers(address, method, stack, static_read_cache_headers()).await
-    }
-
-    async fn run_get_method_with_headers(&self, address: &str, method: &str, stack: Vec<StackArg>, headers: HashMap<String, String>) -> Result<RunGetMethodResult, SwapperError> {
         let result = self
             .ton_client
-            .run_get_method_with_headers(address, method, stack, headers)
+            .run_get_method_with_headers(address, method, stack, static_read_cache_headers())
             .await
             .map_err(|err| SwapperError::ComputeQuoteError(err.to_string()))?;
         if result.exit_code != 0 {

crates/swapper/src/thorchain/client.rs

@@ -2,10 +2,13 @@ use super::{
     asset::THORChainAsset,
     model::{AsgardVault, InboundAddress, QuoteSwapRequest, QuoteSwapResponse, TransactionStatus},
 };
-use crate::SwapperError;
-use gem_client::{Client, ClientExt, X_CACHE_TTL};
+use crate::{SwapperError, cache_headers};
+use gem_client::{Client, ClientExt};
+use primitives::duration::MINUTE;
 use serde_urlencoded;
-use std::{collections::HashMap, fmt::Debug};
+use std::fmt::Debug;
+
+const INBOUND_ADDRESS_CACHE_TTL_SECONDS: u64 = 10 * MINUTE.as_secs();
 
 #[derive(Clone, Debug)]
 pub struct ThorChainSwapClient<C>
@@ -48,8 +51,10 @@ where
     }
 
     pub async fn get_inbound_addresses(&self) -> Result<Vec<InboundAddress>, SwapperError> {
-        let headers = HashMap::from([(X_CACHE_TTL.to_string(), "600".to_string())]);
-        self.client.get_with_headers("/thorchain/inbound_addresses", headers).await.map_err(SwapperError::from)
+        self.client
+            .get_with_headers("/thorchain/inbound_addresses", cache_headers(INBOUND_ADDRESS_CACHE_TTL_SECONDS))
+            .await
+            .map_err(SwapperError::from)
     }
 
     pub async fn get_asgard_vaults(&self) -> Result<Vec<AsgardVault>, SwapperError> {