feat: ekubo manual swap

Author: Yunusabdul38

Cargo.lock

@@ -21,12 +21,12 @@ edition = "2024"
 [dependencies]
 thiserror = "2.0.16"
 serde = {version="1.0.219", features=["derive"]}
-starknet = "0.15.0"
-starknet-contract = "0.15.0"
-starknet-accounts = "0.15.0"
-starknet-providers = "0.15.0"
-starknet-core = "0.15.0"
 tokio = { version = "1.0", features = ["full"] }
 reqwest = { version = "0.12", features = ["json"] }
 url = "2.5"
-hex = "0.4"
+hex = "0.4"
+starknet = "0.17.0"
+starknet-contract = "0.16.0"
+starknet-accounts = "0.16.0"
+starknet-providers = "0.16.0"
+starknet-core = "0.16.0"

Cargo.toml

@@ -1,6 +1,6 @@
 use crate::{
     contracts::{AutoSwapprContract, Erc20Contract},
-    types::connector::{AutoSwapprConfig, AutoSwapprError, ContractInfo, SwapData, Uint256},
+    types::connector::{AutoSwappr, AutoSwapprError, ContractInfo, SwapData, Uint256},
 };
 use starknet::{
     accounts::{Account, ExecutionEncoding, SingleOwnerAccount},
@@ -18,12 +18,12 @@ pub struct AutoSwapprClient {
     provider: Arc<JsonRpcClient<HttpTransport>>,
     autoswappr_contract: AutoSwapprContract,
     account: SingleOwnerAccount<JsonRpcClient<HttpTransport>, LocalWallet>,
-    config: AutoSwapprConfig,
+    config: AutoSwappr,
 }
 
 impl AutoSwapprClient {
     /// Create a new AutoSwappr client with real Starknet integration
-    pub async fn new(config: AutoSwapprConfig) -> Result<Self, AutoSwapprError> {
+    pub async fn new(config: AutoSwappr) -> Result<Self, AutoSwapprError> {
         // Parse RPC URL
         let rpc_url = Url::parse(&config.rpc_url).map_err(|e| AutoSwapprError::InvalidInput {
             details: format!("Invalid RPC URL: {}", e),
@@ -430,7 +430,7 @@ impl AutoSwapprClient {
 mod tests {
     use super::*;
     use crate::types::connector::{
-        Amount, AutoSwapprConfig, PoolKey, SwapData, SwapParameters, Uint256,
+        Amount, AutoSwappr, PoolKey, SwapData, SwapParameters, Uint256,
     };
 
     fn create_test_config() -> AutoSwapprConfig {

src/client.rs

@@ -1,14 +1,25 @@
+mod util;
+use std::sync::LazyLock;
+
+use starknet::core::types::Felt;
+pub use util::u128_to_uint256;
 //Token addresses for common tokens
-#[allow(dead_code)]
-const STRK: &str = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
-#[allow(dead_code)]
-const ETH: &str = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
-#[allow(dead_code)]
-const USDC: &str = "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8";
-#[allow(dead_code)]
-const USDT: &str = "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8";
-#[allow(dead_code)]
-const WBTC: &str = "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
+
+pub static STRK: LazyLock<Felt> = LazyLock::new(|| {
+    Felt::from_hex("0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d").unwrap()
+});
+pub static ETH: LazyLock<Felt> = LazyLock::new(|| {
+    Felt::from_hex("0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7").unwrap()
+});
+pub static USDC: LazyLock<Felt> = LazyLock::new(|| {
+    Felt::from_hex("0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8").unwrap()
+});
+pub static USDT: LazyLock<Felt> = LazyLock::new(|| {
+    Felt::from_hex("0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8").unwrap()
+});
+pub static WBTC: LazyLock<Felt> = LazyLock::new(|| {
+    Felt::from_hex("0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac").unwrap()
+});
 
 #[allow(dead_code)]
 #[derive(Clone)]
@@ -17,44 +28,44 @@ pub struct TokenAddress<'a> {
 }
 
 #[allow(dead_code)]
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 /// Token information for supported tokens
 pub struct TokenInfo<'a> {
-    address: &'a str,
-    symbol: &'a str,
-    decimals: u8,
+    pub address: Felt,
+    pub symbol: &'a str,
+    pub decimals: u8,
     name: &'a str,
 }
 #[allow(dead_code)]
 impl TokenAddress<'static> {
     pub fn new() -> Self {
         let tokens: Vec<TokenInfo> = vec![
             TokenInfo {
-                address: ETH,
+                address: *ETH,
                 symbol: "ETH",
                 decimals: 18,
                 name: "Ether",
             },
             TokenInfo {
-                address: USDC,
+                address: *USDC,
                 symbol: "USDC",
                 decimals: 6,
                 name: "USD Coin",
             },
             TokenInfo {
-                address: USDT,
+                address: *USDT,
                 symbol: "USDT",
                 decimals: 6,
                 name: "Tether USD",
             },
             TokenInfo {
-                address: WBTC,
+                address: *WBTC,
                 symbol: "WBTC",
                 decimals: 8,
                 name: "Wrapped BTC",
             },
             TokenInfo {
-                address: STRK,
+                address: *STRK,
                 symbol: "STRK",
                 decimals: 18,
                 name: "Starknet Token",
@@ -73,14 +84,10 @@ impl TokenAddress<'static> {
             None => Err("TOKEN IS NOT AVAILABLE".to_string()),
         }
     }
-    pub fn get_token_address(&self, address: &'static str) -> Result<&'static str, String> {
-        let token = self
-            .tokens
-            .iter()
-            .find(|x| x.symbol.to_lowercase() == address.to_lowercase())
-            .cloned();
+    pub fn get_token_info_by_address(&self, address: Felt) -> Result<TokenInfo<'static>, String> {
+        let token = self.tokens.iter().find(|x| x.address == address).cloned();
         match token {
-            Some(x) => Ok(x.address),
+            Some(x) => Ok(x),
             None => Err("TOKEN IS NOT AVAILABLE".to_string()),
         }
     }
@@ -92,26 +99,27 @@ mod tests {
 
     #[test]
     fn is_success() {
-        let strk = TokenAddress::new().get_token_info("strk");
-        assert_eq!(strk.unwrap().address, STRK);
-        let usdc = TokenAddress::new().get_token_info("usdc");
-        assert_eq!(usdc.unwrap().address, USDC);
-        let usdt = TokenAddress::new().get_token_info("usdt");
-        assert_eq!(usdt.unwrap().address, USDT);
-        let eth = TokenAddress::new().get_token_info("eth");
-        assert_eq!(eth.unwrap().address, ETH);
-        let eth = TokenAddress::new().get_token_info("eth");
+        let strk = TokenAddress::new().get_token_info_by_address(*STRK);
+        assert_eq!(strk.clone().unwrap().address, *STRK);
+        println!("strk {:?} ", strk);
+        let usdc = TokenAddress::new().get_token_info_by_address(*USDC);
+        assert_eq!(usdc.unwrap().address, *USDC);
+        let usdt = TokenAddress::new().get_token_info_by_address(*USDT);
+        assert_eq!(usdt.unwrap().address, *USDT);
+        let eth = TokenAddress::new().get_token_info_by_address(*ETH);
+        assert_eq!(eth.unwrap().address, *ETH);
+        let eth = TokenAddress::new().get_token_info_by_address(*ETH);
         assert_eq!(eth.unwrap().name, "Ether");
-        let wbtc = TokenAddress::new().get_token_info("wbtc");
-        assert_eq!(wbtc.unwrap().address, WBTC);
-        let wbtc = TokenAddress::new().get_token_info("wbtc");
+        let wbtc = TokenAddress::new().get_token_info_by_address(*WBTC);
+        assert_eq!(wbtc.unwrap().address, *WBTC);
+        let wbtc = TokenAddress::new().get_token_info_by_address(*WBTC);
         assert_eq!(wbtc.unwrap().decimals, 8);
     }
 
     #[test]
     #[should_panic(expected = "TOKEN IS NOT AVAILABLE")]
     fn should_panic() {
         let strk = TokenAddress::new().get_token_info("sol");
-        assert_eq!(strk.unwrap().address, STRK);
+        assert_eq!(strk.unwrap().address, *STRK);
     }
 }

src/constant/mod.rs

@@ -0,0 +1,8 @@
+use starknet::core::types::Felt;
+
+// Helper function to convert u128 to (low, high) felts for uint256
+pub fn u128_to_uint256(amount: u128) -> (Felt, Felt) {
+    let amount_low = Felt::from(amount & 0xFFFFFFFFFFFFFFFF); // Lower 64 bits (NOT 128!)
+    let amount_high = Felt::from(amount >> 64); // Upper 64 bits
+    (amount_low, amount_high)
+}

src/constant/util.rs

@@ -1,21 +1,21 @@
-pub mod client;
+// pub mod client;
 pub mod constant;
-pub mod contracts;
+// pub mod contracts;
 pub mod provider;
 pub mod simple_client;
+pub mod swappr;
 pub mod types;
-
-#[cfg(test)]
-mod contracts_test;
+// #[cfg(test)]
+// mod contracts_test;
 
 // Re-export main types and clients for easy access
-pub use client::AutoSwapprClient;
-pub use contracts::{AutoSwapprContract, Erc20Contract, addresses};
+// pub use client::AutoSwapprClient;
+// pub use contracts::{AutoSwapprContract, Erc20Contract, addresses,conversions::u128_to_uint256};
 pub use provider::{Network, StarknetProvider};
 pub use simple_client::{
     SimpleAutoSwapprClient, SimpleConfig, SimpleError, SwapData as SimpleSwapData,
 };
 pub use types::connector::{
-    Amount, AutoSwapprConfig, AutoSwapprError, ContractInfo, Delta, FeeType, I129, PoolKey, Route,
-    RouteParams, SwapData, SwapOptions, SwapParameters, SwapParams, SwapResult, TokenInfo, Uint256,
+    AutoSwappr, AutoSwapprError, ContractInfo, Delta, FeeType, I129, PoolKey, Route, RouteParams,
+    SwapData, SwapOptions, SwapParameters, SwapParams, SwapResult, TokenInfo, Uint256,
 };