feat: Take Chain object containing native/wrapped addresses

- This way this chain object contains everything we need, we don't need to worry about doing any transformation or calling any supplementary functions inside any of the encoders
- Needed to move our new Chain object to a higher level since this is used in the higher-level encoder traits. This required some weird default values in the constants in order to avoid using alloy's hex literal. I could have instead opted to make Bytes parse a string I think, though this would mean possibly returning an error at the constants level, which is not nice either.

Question:
- Do we want the user to be in charge of passing the native and wrapped token every single time? This may be a bit annoying for the user. For now, I have defaulted to those in constants.rs, this would take 5 mins to remove though if you don't like it, and it would get rid of this complicated bytes initialization.

Cargo.lock

@@ -4242,6 +4242,7 @@ dependencies = [
  "lazy_static",
  "num-bigint",
  "num-traits",
+ "once_cell",
  "rstest",
  "serde",
  "serde_json",

Cargo.toml

@@ -19,6 +19,7 @@ alloy = { version = "0.9.2", features = ["providers", "rpc-types-eth", "eip712",
 alloy-sol-types = { version = "0.8.14", optional = true }
 alloy-primitives = { version = "0.8.9", optional = true }
 tycho-core = { git = "https://github.com/propeller-heads/tycho-indexer.git", package = "tycho-core", tag = "0.46.0" }
+once_cell = "1.20.2"
 
 [dev-dependencies]
 rstest = "0.24.0"

examples/quickstart/main.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use num_bigint::BigUint;
 use tycho_core::{
-    dto::{Chain, ProtocolComponent},
+    dto::{Chain as TychoCoreChain, ProtocolComponent},
     Bytes,
 };
 use tycho_execution::encoding::{
@@ -10,7 +10,7 @@ use tycho_execution::encoding::{
         strategy_encoder::strategy_encoder_registry::EVMStrategyEncoderRegistry,
         tycho_encoder::EVMTychoEncoder,
     },
-    models::{Solution, Swap},
+    models::{Chain, Solution, Swap},
     strategy_encoder::StrategyEncoderRegistry,
     tycho_encoder::TychoEncoder,
 };
@@ -24,11 +24,13 @@ fn main() {
         .expect("Failed to create user address");
     let executors_file_path = "src/encoding/config/executor_addresses.json";
 
+    let eth_chain = Chain::from_tycho_core_chain(TychoCoreChain::Ethereum, None, None)
+        .expect("Failed to create chain.");
     // Initialize the encoder
     let strategy_encoder_registry =
-        EVMStrategyEncoderRegistry::new(Chain::Ethereum, executors_file_path, signer_pk.clone())
+        EVMStrategyEncoderRegistry::new(eth_chain.clone(), executors_file_path, signer_pk.clone())
             .expect("Failed to create strategy encoder registry");
-    let encoder = EVMTychoEncoder::new(strategy_encoder_registry, router_address, Chain::Ethereum)
+    let encoder = EVMTychoEncoder::new(strategy_encoder_registry, router_address, eth_chain)
         .expect("Failed to create encoder");
 
     // ------------------- Encode a simple swap -------------------

src/encoding/constants.rs

@@ -0,0 +1,19 @@
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
+use tycho_core::{dto::Chain, Bytes};
+const ETH_NATIVE: &[u8] = &[
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+];
+
+const ETH_WRAPPED: &[u8] = &[
+    0xc0, 0x2a, 0xaa, 0x39, 0xb2, 0x23, 0xfe, 0x8d, 0x0a, 0x0e, 0x5c, 0x4f, 0x27, 0xea, 0xd9, 0x08,
+    0x3c, 0x75, 0x6c, 0xc2,
+];
+
+pub static NATIVE_ADDRESSES: Lazy<HashMap<Chain, Bytes>> =
+    Lazy::new(|| HashMap::from([(Chain::Ethereum, Bytes::from(ETH_NATIVE))]));
+
+pub static WRAPPED_ADDRESSES: Lazy<HashMap<Chain, Bytes>> =
+    Lazy::new(|| HashMap::from([(Chain::Ethereum, Bytes::from(ETH_WRAPPED))]));

src/encoding/evm/approvals/permit2.rs

@@ -12,15 +12,15 @@ use alloy_sol_types::{eip712_domain, sol, SolStruct, SolValue};
 use chrono::Utc;
 use num_bigint::BigUint;
 use tokio::runtime::Runtime;
-use tycho_core::{dto::Chain, Bytes};
+use tycho_core::Bytes;
 
 use crate::encoding::{
     errors::EncodingError,
     evm::{
         approvals::protocol_approvals_manager::get_client,
-        models::ChainId,
         utils::{biguint_to_u256, bytes_to_address, encode_input},
     },
+    models::{Chain, ChainId},
 };
 
 /// Struct for managing Permit2 operations, including encoding approvals and fetching allowance
@@ -60,7 +60,6 @@ sol! {
 
 impl Permit2 {
     pub fn new(signer_pk: String, chain: Chain) -> Result<Self, EncodingError> {
-        let chain_id = ChainId::from(chain);
         let runtime = Runtime::new()
             .map_err(|_| EncodingError::FatalError("Failed to create runtime".to_string()))?;
         let client = runtime.block_on(get_client())?;
@@ -76,7 +75,7 @@ impl Permit2 {
             client,
             runtime,
             signer,
-            chain_id,
+            chain_id: chain.id,
         })
     }
 
@@ -199,11 +198,28 @@ mod tests {
         }
     }
 
+    fn eth() -> Bytes {
+        Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap()
+    }
+
+    fn weth() -> Bytes {
+        Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()
+    }
+
+    fn eth_chain() -> Chain {
+        Chain {
+            id: ChainId(1),
+            name: String::from("ethereum"),
+            native_token: eth(),
+            wrapped_token: weth(),
+        }
+    }
+
     #[test]
     fn test_get_existing_allowance() {
         let signer_pk =
             "4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
-        let manager = Permit2::new(signer_pk, Chain::Ethereum).unwrap();
+        let manager = Permit2::new(signer_pk, eth_chain()).unwrap();
 
         let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
         let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
@@ -223,7 +239,7 @@ mod tests {
         // Set up a mock private key for signing
         let private_key =
             "4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
-        let permit2 = Permit2::new(private_key, Chain::Ethereum).expect("Failed to create Permit2");
+        let permit2 = Permit2::new(private_key, eth_chain()).expect("Failed to create Permit2");
 
         let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
         let spender = Bytes::from_str("0xba12222222228d8ba445958a75a0704d566bf2c8").unwrap();
@@ -264,7 +280,7 @@ mod tests {
             "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".to_string();
 
         let permit2 =
-            Permit2::new(anvil_private_key, Chain::Ethereum).expect("Failed to create Permit2");
+            Permit2::new(anvil_private_key, eth_chain()).expect("Failed to create Permit2");
 
         let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
         let amount = BigUint::from(1000u64);

src/encoding/evm/constants.rs

@@ -1,18 +0,0 @@
-use alloy_primitives::hex;
-use tycho_core::{dto::Chain, Bytes};
-
-pub fn native_address(chain: Chain) -> Bytes {
-    match chain {
-        Chain::Ethereum => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
-        // Placeholder values for other chains; update with real addresses
-        _ => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
-    }
-}
-
-pub fn wrapped_address(chain: Chain) -> Bytes {
-    match chain {
-        Chain::Ethereum => Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec()),
-        // Placeholder values for other chains; update with real addresses
-        _ => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
-    }
-}

src/encoding/evm/mod.rs

@@ -1,6 +1,4 @@
 pub mod approvals;
-mod constants;
-mod models;
 pub mod strategy_encoder;
 mod swap_encoder;
 pub mod tycho_encoder;

src/encoding/evm/models.rs

@@ -1,20 +0,0 @@
-use tycho_core::dto::Chain;
-
-pub struct ChainId(u64);
-
-impl ChainId {
-    pub fn id(&self) -> u64 {
-        self.0
-    }
-}
-
-impl From<Chain> for ChainId {
-    fn from(chain: Chain) -> Self {
-        match chain {
-            Chain::Ethereum => ChainId(1),
-            Chain::ZkSync => ChainId(324),
-            Chain::Arbitrum => ChainId(42161),
-            Chain::Starknet => ChainId(0),
-        }
-    }
-}

src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs

@@ -1,14 +1,12 @@
 use std::collections::HashMap;
 
-use tycho_core::dto::Chain;
-
 use crate::encoding::{
     errors::EncodingError,
     evm::{
         strategy_encoder::strategy_encoders::{ExecutorStrategyEncoder, SplitSwapStrategyEncoder},
         swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
     },
-    models::Solution,
+    models::{Chain, Solution},
     strategy_encoder::{StrategyEncoder, StrategyEncoderRegistry},
 };
 
@@ -22,7 +20,7 @@ impl StrategyEncoderRegistry for EVMStrategyEncoderRegistry {
         executors_file_path: &str,
         signer_pk: Option<String>,
     ) -> Result<Self, EncodingError> {
-        let swap_encoder_registry = SwapEncoderRegistry::new(executors_file_path, Chain::Ethereum)?;
+        let swap_encoder_registry = SwapEncoderRegistry::new(executors_file_path, chain.clone())?;
 
         let mut strategies: HashMap<String, Box<dyn StrategyEncoder>> = HashMap::new();
         strategies.insert(

src/encoding/evm/strategy_encoder/strategy_encoders.rs

@@ -7,17 +7,16 @@ use std::{
 use alloy_primitives::{aliases::U24, FixedBytes, U256, U8};
 use alloy_sol_types::SolValue;
 use num_bigint::BigUint;
-use tycho_core::{dto::Chain, keccak256, Bytes};
+use tycho_core::{keccak256, Bytes};
 
 use crate::encoding::{
     errors::EncodingError,
     evm::{
         approvals::permit2::Permit2,
-        constants::{native_address, wrapped_address},
         swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
         utils::{biguint_to_u256, bytes_to_address, encode_input, percentage_to_uint24},
     },
-    models::{EncodingContext, NativeAction, Solution, Swap},
+    models::{Chain, EncodingContext, NativeAction, Solution, Swap},
     strategy_encoder::StrategyEncoder,
     swap_encoder::SwapEncoder,
 };
@@ -62,8 +61,8 @@ pub struct SplitSwapStrategyEncoder {
     swap_encoder_registry: SwapEncoderRegistry,
     permit2: Permit2,
     selector: String,
-    wrapped_address: Bytes,
     native_address: Bytes,
+    wrapped_address: Bytes,
 }
 
 impl SplitSwapStrategyEncoder {
@@ -73,14 +72,12 @@ impl SplitSwapStrategyEncoder {
         swap_encoder_registry: SwapEncoderRegistry,
     ) -> Result<Self, EncodingError> {
         let selector = "swap(uint256,address,address,uint256,bool,bool,uint256,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)".to_string();
-        let wrapped_address = wrapped_address(chain);
-        let native_address = native_address(chain);
         Ok(Self {
-            permit2: Permit2::new(signer_pk, chain)?,
+            permit2: Permit2::new(signer_pk, chain.clone())?,
             selector,
             swap_encoder_registry,
-            wrapped_address,
+            native_address: chain.native_token.clone(),
-            native_address,
+            wrapped_address: chain.wrapped_token.clone(),
         })
     }
 
@@ -434,26 +431,37 @@ mod tests {
     use std::str::FromStr;
 
     use alloy::hex::encode;
+    use alloy_primitives::hex;
     use num_bigint::BigUint;
     use rstest::rstest;
-    use tycho_core::{dto::ProtocolComponent, Bytes};
+    use tycho_core::{
+        dto::{Chain as TychoCoreChain, ProtocolComponent},
+        Bytes,
+    };
 
     use super::*;
-    use crate::encoding::{
+    use crate::encoding::models::{ChainId, Swap};
-        evm::constants::{native_address, wrapped_address},
+
-        models::Swap,
+    fn eth_chain() -> Chain {
-    };
+        Chain {
+            id: ChainId(1),
+            name: TychoCoreChain::Ethereum.to_string(),
+            native_token: eth(),
+            wrapped_token: weth(),
+        }
+    }
+
     fn eth() -> Bytes {
-        native_address(Chain::Ethereum)
+        Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec())
     }
 
     fn weth() -> Bytes {
-        wrapped_address(Chain::Ethereum)
+        Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec())
     }
 
     fn get_swap_encoder_registry() -> SwapEncoderRegistry {
-        SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", Chain::Ethereum)
+        let eth_chain = eth_chain();
-            .unwrap()
+        SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", eth_chain).unwrap()
     }
 
     #[test]
@@ -567,8 +575,7 @@ mod tests {
         };
         let swap_encoder_registry = get_swap_encoder_registry();
         let encoder =
-            SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
+            SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
-                .unwrap();
         let solution = Solution {
             exact_out: false,
             given_token: weth,
@@ -669,8 +676,7 @@ mod tests {
         };
         let swap_encoder_registry = get_swap_encoder_registry();
         let encoder =
-            SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
+            SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
-                .unwrap();
         let solution = Solution {
             exact_out: false,
             given_token: eth(),
@@ -718,8 +724,7 @@ mod tests {
         };
         let swap_encoder_registry = get_swap_encoder_registry();
         let encoder =
-            SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
+            SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
-                .unwrap();
         let solution = Solution {
             exact_out: false,
             given_token: dai,
@@ -808,8 +813,7 @@ mod tests {
         };
         let swap_encoder_registry = get_swap_encoder_registry();
         let encoder =
-            SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
+            SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
-                .unwrap();
         let solution = Solution {
             exact_out: false,
             given_token: weth,
@@ -836,7 +840,7 @@ mod tests {
         let private_key =
             "0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
         let swap_encoder_registry = get_swap_encoder_registry();
-        SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry).unwrap()
+        SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap()
     }
 
     #[test]

src/encoding/evm/swap_encoder/swap_encoder_registry.rs

@@ -1,9 +1,7 @@
 use std::{collections::HashMap, fs};
 
-use tycho_core::dto::Chain;
-
 use crate::encoding::{
-    errors::EncodingError, evm::swap_encoder::builder::SwapEncoderBuilder,
+    errors::EncodingError, evm::swap_encoder::builder::SwapEncoderBuilder, models::Chain,
     swap_encoder::SwapEncoder,
 };
 
@@ -15,10 +13,10 @@ pub struct SwapEncoderRegistry {
 impl SwapEncoderRegistry {
     pub fn new(executors_file_path: &str, blockchain: Chain) -> Result<Self, EncodingError> {
         let config_str = fs::read_to_string(executors_file_path)?;
-        let config: HashMap<Chain, HashMap<String, String>> = serde_json::from_str(&config_str)?;
+        let config: HashMap<String, HashMap<String, String>> = serde_json::from_str(&config_str)?;
         let mut encoders = HashMap::new();
         let executors = config
-            .get(&blockchain)
+            .get(&blockchain.name)
             .ok_or(EncodingError::FatalError("No executors found for blockchain".to_string()))?;
         for (protocol, executor_address) in executors {
             let builder = SwapEncoderBuilder::new(protocol, executor_address);

src/encoding/evm/tycho_encoder.rs

@@ -1,12 +1,11 @@
 use std::str::FromStr;
 
 use num_bigint::BigUint;
-use tycho_core::{dto::Chain, Bytes};
+use tycho_core::Bytes;
 
 use crate::encoding::{
     errors::EncodingError,
-    evm::constants::{native_address, wrapped_address},
+    models::{Chain, NativeAction, Solution, Transaction},
-    models::{NativeAction, Solution, Transaction},
     strategy_encoder::StrategyEncoderRegistry,
     tycho_encoder::TychoEncoder,
 };
@@ -26,14 +25,17 @@ impl<S: StrategyEncoderRegistry> EVMTychoEncoder<S> {
     ) -> Result<Self, EncodingError> {
         let router_address = Bytes::from_str(&router_address)
             .map_err(|_| EncodingError::FatalError("Invalid router address".to_string()))?;
-        let native_address = native_address(chain);
+        if chain.name != *"ethereum" {
-        let wrapped_address = wrapped_address(chain);
-        if chain != Chain::Ethereum {
             return Err(EncodingError::InvalidInput(
                 "Currently only Ethereum is supported".to_string(),
             ));
         }
-        Ok(EVMTychoEncoder { strategy_selector, router_address, native_address, wrapped_address })
+        Ok(EVMTychoEncoder {
+            strategy_selector,
+            router_address,
+            native_address: chain.native_token,
+            wrapped_address: chain.wrapped_token,
+        })
     }
 }
 
@@ -119,27 +121,38 @@ impl<S: StrategyEncoderRegistry> TychoEncoder<S> for EVMTychoEncoder<S> {
 
 #[cfg(test)]
 mod tests {
-    use tycho_core::dto::{Chain, ProtocolComponent};
+    use tycho_core::dto::{Chain as TychoCoreChain, ProtocolComponent};
 
     use super::*;
     use crate::encoding::{
-        models::Swap, strategy_encoder::StrategyEncoder, swap_encoder::SwapEncoder,
+        models::{ChainId, Swap},
+        strategy_encoder::StrategyEncoder,
+        swap_encoder::SwapEncoder,
     };
 
     struct MockStrategyRegistry {
         strategy: Box<dyn StrategyEncoder>,
     }
 
+    fn eth_chain() -> Chain {
+        Chain {
+            id: ChainId(1),
+            name: TychoCoreChain::Ethereum.to_string(),
+            native_token: eth(),
+            wrapped_token: weth(),
+        }
+    }
+
     fn dai() -> Bytes {
         Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap()
     }
 
     fn eth() -> Bytes {
-        native_address(Chain::Ethereum)
+        Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap()
     }
 
     fn weth() -> Bytes {
-        wrapped_address(Chain::Ethereum)
+        Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()
     }
 
     impl StrategyEncoderRegistry for MockStrategyRegistry {
@@ -181,11 +194,11 @@ mod tests {
     }
 
     fn get_mocked_tycho_encoder() -> EVMTychoEncoder<MockStrategyRegistry> {
-        let strategy_selector = MockStrategyRegistry::new(Chain::Ethereum, "", None).unwrap();
+        let strategy_selector = MockStrategyRegistry::new(eth_chain(), "", None).unwrap();
         EVMTychoEncoder::new(
             strategy_selector,
             "0x1234567890abcdef1234567890abcdef12345678".to_string(),
-            Chain::Ethereum,
+            eth_chain(),
         )
         .unwrap()
     }

src/encoding/mod.rs

@@ -1,3 +1,4 @@
+pub mod constants;
 mod errors;
 #[cfg(feature = "evm")]
 pub mod evm;

src/encoding/models.rs

@@ -1,5 +1,13 @@
 use num_bigint::BigUint;
-use tycho_core::{dto::ProtocolComponent, Bytes};
+use tycho_core::{
+    dto::{Chain as TychoCoreChain, ProtocolComponent},
+    Bytes,
+};
+
+use crate::encoding::{
+    constants::{NATIVE_ADDRESSES, WRAPPED_ADDRESSES},
+    errors::EncodingError,
+};
 
 #[derive(Clone, Default, Debug)]
 pub struct Solution {
@@ -68,3 +76,65 @@ pub struct EncodingContext {
     pub exact_out: bool,
     pub router_address: Bytes,
 }
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct ChainId(pub u64);
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Chain {
+    pub id: ChainId,
+    pub name: String,
+    pub native_token: Bytes,
+    pub wrapped_token: Bytes,
+}
+
+impl ChainId {
+    pub fn id(&self) -> u64 {
+        self.0
+    }
+}
+
+impl From<TychoCoreChain> for ChainId {
+    fn from(chain: TychoCoreChain) -> Self {
+        match chain {
+            TychoCoreChain::Ethereum => ChainId(1),
+            TychoCoreChain::ZkSync => ChainId(324),
+            TychoCoreChain::Arbitrum => ChainId(42161),
+            TychoCoreChain::Starknet => ChainId(0),
+        }
+    }
+}
+
+impl Chain {
+    pub fn from_tycho_core_chain(
+        chain: TychoCoreChain,
+        native_token: Option<Bytes>,
+        wrapped_token: Option<Bytes>,
+    ) -> Result<Self, EncodingError> {
+        let native_token_address = match native_token {
+            Some(token) => token,
+            None => NATIVE_ADDRESSES.get(&chain)
+                .cloned()
+                .ok_or_else(|| EncodingError::InvalidInput(format!(
+                    "Native token does not have a default address for chain {:?}. Please pass the native token address",
+                    chain
+                )))?,
+        };
+
+        let wrapped_token_address = match wrapped_token {
+            Some(token) => token,
+            None => WRAPPED_ADDRESSES.get(&chain)
+                .cloned()
+                .ok_or_else(|| EncodingError::InvalidInput(format!(
+                    "Wrapped token does not have a default address for chain {:?}. Please pass the wrapped token address",
+                    chain
+                )))?,
+        };
+        Ok(Chain {
+            id: chain.into(),
+            name: chain.to_string(),
+            native_token: native_token_address,
+            wrapped_token: wrapped_token_address,
+        })
+    }
+}

src/encoding/strategy_encoder.rs

@@ -1,6 +1,10 @@
-use tycho_core::{dto::Chain, Bytes};
+use tycho_core::Bytes;
 
-use crate::encoding::{errors::EncodingError, models::Solution, swap_encoder::SwapEncoder};
+use crate::encoding::{
+    errors::EncodingError,
+    models::{Chain, Solution},
+    swap_encoder::SwapEncoder,
+};
 
 pub trait StrategyEncoder {
     fn encode_strategy(