Add flag to disable caching responses

.env.example

@@ -7,6 +7,7 @@ QUICKNODE_TOKEN=your_token_here
 # Proxy settings
 PROXY_PORT=8545
 CACHE_SIZE_GB=100
+DISABLE_CACHE=true
 BACKOFF_MINUTES=30
 
 # Logging

main.py

@@ -36,6 +36,7 @@ def load_config() -> dict:
     return {
         "proxy_port": int(os.getenv("PROXY_PORT", 8545)),
         "cache_size_gb": int(os.getenv("CACHE_SIZE_GB", 100)),
+        "disable_cache": os.getenv("DISABLE_CACHE", "true").lower() == "true",
         "backoff_minutes": int(os.getenv("BACKOFF_MINUTES", 30)),
         "log_level": os.getenv("LOG_LEVEL", "INFO"),
         "error_db_path": os.getenv("ERROR_DB_PATH", "./errors.db"),
@@ -55,7 +56,7 @@ def create_app(config: dict) -> web.Application:
     providers = create_providers()
     cache = Cache(size_limit_gb=config["cache_size_gb"])
     error_logger = ErrorLogger(db_path=config["error_db_path"])
-    router = Router(providers, cache, error_logger)
+    router = Router(providers, cache, error_logger, config["disable_cache"])
 
     app['router'] = router
     app['config'] = config
@@ -72,7 +73,10 @@ def main() -> None:
 
     logger = logging.getLogger(__name__)
     logger.info(f"Starting Solana RPC Proxy on port {config['proxy_port']}")
-    logger.info(f"Cache size limit: {config['cache_size_gb']}GB")
+    if config['disable_cache']:
+        logger.info("Cache is DISABLED - all responses will be fresh")
+    else:
+        logger.info(f"Cache size limit: {config['cache_size_gb']}GB")
     logger.info(f"Provider backoff time: {config['backoff_minutes']} minutes")
 
     app = create_app(config)

router.py

@@ -8,22 +8,24 @@ from errors import ErrorLogger
 
 
 class Router:
-    def __init__(self, providers: List[Provider], cache: Cache, error_logger: ErrorLogger):
+    def __init__(self, providers: List[Provider], cache: Cache, error_logger: ErrorLogger, disable_cache: bool = False):
         self.providers = providers
         self.cache = cache
         self.error_logger = error_logger
+        self.disable_cache = disable_cache
         self.current_provider_index = 0
         self.logger = logging.getLogger(__name__)
 
     async def route_request(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
         request = {"method": method, "params": params}
 
-        cached_response = self.cache.get(method, params)
+        if not self.disable_cache:
-        if cached_response:
+            cached_response = self.cache.get(method, params)
-            self.logger.debug(f"Cache hit for {method}")
+            if cached_response:
-            cached_response["_cached"] = True
+                self.logger.debug(f"Cache hit for {method}")
-            cached_response["_provider"] = "cache"
+                cached_response["_cached"] = True
-            return cached_response
+                cached_response["_provider"] = "cache"
+                return cached_response
 
         for attempt in range(len(self.providers)):
             provider = self.get_next_available_provider()
@@ -40,7 +42,8 @@ class Router:
                 transformed_response["_cached"] = False
                 transformed_response["_provider"] = provider.name
 
-                self.cache.set(method, params, transformed_response)
+                if not self.disable_cache:
+                    self.cache.set(method, params, transformed_response)
                 self.logger.info(f"Request succeeded via {provider.name}")
                 return transformed_response
 

ws_proxy.py

@@ -127,7 +127,7 @@ class WebSocketProxy:
 
                     method = transformed_response.get("method", "")
                     params = transformed_response.get("params", {})
-                    if method and params:
+                    if method and params and not self.router.disable_cache:
                         self.router.cache.set(method, params, transformed_response)
 
                     await client_ws.send_str(json.dumps(transformed_response))