Remove unused binance api (#3695)

* init

* update

Author: Kailai-Wang

tee-worker/omni-executor/native-task-handler/src/lib.rs

@@ -42,7 +42,7 @@ use pumpx::{
 use signer_client::{ChainType, SignerClient};
 use std::{collections::HashMap, marker::PhantomData, sync::Arc};
 use tokio::sync::{mpsc, oneshot};
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info};
 
 pub use aes256_key_store::Aes256KeyStore;
 pub use types::{NativeTaskError, NativeTaskOk, PumpxApiError, PumpxSignerError};
@@ -217,66 +217,6 @@ fn get_supported_tokens() -> std::collections::HashMap<(u64, &'static str), Toke
 	tokens
 }
 
-// Dynamic token discovery using Binance API
-// Fetch all available trading symbols from Binance to potentially expand supported tokens
-async fn discover_tokens_from_binance(
-	binance_api: &dyn BinancePaymasterApi,
-) -> Result<Vec<String>, String> {
-	binance_api
-		.get_all_trading_symbols()
-		.await
-		.map_err(|e| format!("Failed to fetch trading symbols from Binance: {:?}", e))
-}
-
-// Enhanced token lookup that first checks hardcoded list, then attempts dynamic discovery
-async fn get_token_info_for_binance_enhanced(
-	token_address: &Address,
-	chain_id: u64,
-	binance_api_client: Option<&dyn BinancePaymasterApi>,
-) -> Option<(String, u8)> {
-	// First try the existing hardcoded lookup
-	if let Some(result) = get_token_info_from_mapping(token_address, chain_id).await {
-		return Some(result);
-	}
-
-	// If not found in hardcoded list and we have a Binance API client, try dynamic discovery
-	if let Some(binance_client) = binance_api_client {
-		info!("Token {} not found in hardcoded list, attempting dynamic discovery", token_address);
-
-		match discover_tokens_from_binance(binance_client).await {
-			Ok(symbols) => {
-				// Look for common patterns that might match our token
-				// This is a heuristic approach - in a real implementation you'd want a more sophisticated
-				// mapping service that knows token symbols across different chains
-				for symbol in symbols {
-					// Look for ETH-based pairs (ETHUSDC, ETHUSDT, etc.)
-					if symbol.starts_with("ETH") && symbol.len() > 3 {
-						let token_symbol = &symbol[3..]; // Remove "ETH" prefix
-
-						// Try to get decimals from the exchange
-						if let Ok(decimals) = binance_client.get_symbol_precision(&symbol).await {
-							info!(
-								"Found potential token {} via dynamic discovery with symbol {} and {} decimals",
-								token_address, token_symbol, decimals
-							);
-							return Some((symbol, decimals));
-						}
-					}
-				}
-				warn!(
-					"Dynamic discovery did not find a suitable match for token {}",
-					token_address
-				);
-			},
-			Err(e) => {
-				warn!("Dynamic token discovery failed: {}", e);
-			},
-		}
-	}
-
-	None
-}
-
 // Map token address to Binance symbol and return (symbol, decimals) from hardcoded mapping
 async fn get_token_info_from_mapping(
 	token_address: &Address,
@@ -362,11 +302,10 @@ async fn process_erc20_paymaster_data(
 			token_address, original_rate, valid_until, valid_after
 		);
 
-		// Get token symbol and decimals for Binance API (with dynamic discovery fallback)
-		let (token_symbol, token_decimals) = match get_token_info_for_binance_enhanced(
+		// Get token symbol and decimals from hardcoded mapping
+		let (token_symbol, token_decimals) = match get_token_info_from_mapping(
 			&token_address,
 			chain_id,
-			Some(binance_api),
 		)
 		.await
 		{
@@ -2482,36 +2421,6 @@ mod erc20_paymaster_tests {
 		assert_eq!(PAYMASTER_DATA_OFFSET, 52);
 	}
 
-	#[cfg(feature = "mocks")]
-	#[test]
-	fn test_discover_tokens_from_binance() {
-		use binance_api::mocks::MockBinanceApiClient;
-		use binance_api::BinancePaymasterApi;
-
-		let rt = tokio::runtime::Runtime::new().unwrap();
-		let mut mock_client = MockBinanceApiClient::new();
-
-		// Mock the get_all_trading_symbols call
-		mock_client.expect_get_all_trading_symbols().times(1).returning(|| {
-			Ok(vec![
-				"ETHUSDC".to_string(),
-				"ETHUSDT".to_string(),
-				"ETHDAI".to_string(),
-				"BTCUSDT".to_string(), // Should be ignored as it doesn't start with ETH
-			])
-		});
-
-		let result = rt.block_on(discover_tokens_from_binance(&mock_client));
-		assert!(result.is_ok());
-
-		let symbols = result.unwrap();
-		assert_eq!(symbols.len(), 4);
-		assert!(symbols.contains(&"ETHUSDC".to_string()));
-		assert!(symbols.contains(&"ETHUSDT".to_string()));
-		assert!(symbols.contains(&"ETHDAI".to_string()));
-		assert!(symbols.contains(&"BTCUSDT".to_string()));
-	}
-
 	#[test]
 	fn test_paymaster_data_alignment_with_contract() {
 		// This test ensures our format exactly matches ERC20PaymasterV1.sol
@@ -2564,86 +2473,6 @@ mod erc20_paymaster_tests {
 		assert_eq!(redecoded.2, until + 100); // Until updated
 		assert_eq!(redecoded.3, after + 100); // After updated
 	}
-
-	#[test]
-	fn test_get_token_info_for_binance_enhanced_hardcoded_mapping() {
-		let rt = tokio::runtime::Runtime::new().unwrap();
-
-		// Test USDC on Ethereum mainnet (should be found in hardcoded mapping)
-		// USDC address: 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
-		let usdc_address = Address::from([
-			0xa0, 0xb8, 0x69, 0x91, 0xc6, 0x21, 0x8b, 0x36, 0xc1, 0xd1, 0x9d, 0x4a, 0x2e, 0x9e,
-			0xb0, 0xce, 0x36, 0x06, 0xeb, 0x48,
-		]);
-		let result = rt.block_on(get_token_info_for_binance_enhanced(&usdc_address, 1, None));
-
-		assert!(result.is_some());
-		let (symbol, decimals) = result.unwrap();
-		assert_eq!(symbol, "ETHUSDC");
-		assert_eq!(decimals, 6);
-	}
-
-	#[test]
-	fn test_get_token_info_for_binance_enhanced_unknown_token_no_api() {
-		let rt = tokio::runtime::Runtime::new().unwrap();
-
-		// Test unknown token without Binance API client
-		let unknown_address = Address::from([0xFF; 20]);
-		let result = rt.block_on(get_token_info_for_binance_enhanced(&unknown_address, 1, None));
-
-		assert!(result.is_none());
-	}
-
-	#[cfg(feature = "mocks")]
-	#[test]
-	fn test_get_token_info_for_binance_enhanced_unknown_token_with_api() {
-		use binance_api::mocks::MockBinanceApiClient;
-		use binance_api::BinancePaymasterApi;
-
-		let rt = tokio::runtime::Runtime::new().unwrap();
-		let mut mock_client = MockBinanceApiClient::new();
-
-		// Mock the get_all_trading_symbols call to return some example symbols
-		mock_client.expect_get_all_trading_symbols().times(1).returning(|| {
-			Ok(vec!["ETHUSDC".to_string(), "ETHUSDT".to_string(), "ETHDAI".to_string()])
-		});
-
-		// Test unknown token with Binance API client
-		let unknown_address = Address::from([0xFF; 20]);
-		let result = rt.block_on(get_token_info_for_binance_enhanced(
-			&unknown_address,
-			1,
-			Some(&mock_client as &dyn BinancePaymasterApi),
-		));
-
-		// Should still return None as dynamic discovery would need actual token contract calls
-		// which are not implemented in this simple mock test
-		assert!(result.is_none());
-	}
-
-	#[test]
-	fn test_get_token_info_for_binance_enhanced_different_chains() {
-		let rt = tokio::runtime::Runtime::new().unwrap();
-
-		// Test USDC on Arbitrum (should be found in hardcoded mapping)
-		// USDC Arbitrum address: 0xaf88d065e77c8cc2239327c5edb3a432268e5831
-		let usdc_arbitrum_address = Address::from([
-			0xaf, 0x88, 0xd0, 0x65, 0xe7, 0x7c, 0x8c, 0xc2, 0x23, 0x93, 0x27, 0xc5, 0xed, 0xb3,
-			0xa4, 0x32, 0x26, 0x8e, 0x58, 0x31,
-		]);
-		let result =
-			rt.block_on(get_token_info_for_binance_enhanced(&usdc_arbitrum_address, 42161, None));
-
-		assert!(result.is_some());
-		let (symbol, decimals) = result.unwrap();
-		assert_eq!(symbol, "ETHUSDC");
-		assert_eq!(decimals, 6);
-
-		// Test same address on different chain (should return None)
-		let result_wrong_chain =
-			rt.block_on(get_token_info_for_binance_enhanced(&usdc_arbitrum_address, 1, None));
-		assert!(result_wrong_chain.is_none());
-	}
 }
 
 #[cfg(test)]