docs: More docs and improvements of existing docs

- Tried not to leave a single public function undocumented, though did not double-document public function with obvious names
- Remove all mentions of the strategy selector in favour of the strategy registry (to avoid confusion)

src/encoding/evm/approvals/protocol_approvals_manager.rs

@@ -25,7 +25,7 @@ impl ProtocolApprovalsManager {
         Ok(Self { client, runtime })
     }
 
-    /// Checks the current allowance for the given token, owner, and spender, and returns True
+    /// Checks the current allowance for the given token, owner, and spender, and returns true
     /// if the current allowance is zero.
     pub fn approval_needed(
         &self,
@@ -60,6 +60,7 @@ impl ProtocolApprovalsManager {
     }
 }
 
+/// Gets the client used for interacting with the EVM-compatible network.
 pub async fn get_client() -> Result<Arc<RootProvider<BoxTransport>>, EncodingError> {
     dotenv().ok();
     let eth_rpc_url = env::var("ETH_RPC_URL")

src/encoding/evm/strategy_encoder/strategy_encoders.rs

@@ -18,7 +18,10 @@ use crate::encoding::{
     swap_encoder::SwapEncoder,
 };
 
+/// Encodes a solution using a specific strategy for execution on the EVM-compatible network.
 pub trait EVMStrategyEncoder: StrategyEncoder {
+    /// Encodes information necessary for performing a single swap against a given executor for
+    /// a protocol.
     fn encode_swap_header(
         &self,
         token_in: U8,
@@ -37,11 +40,17 @@ pub trait EVMStrategyEncoder: StrategyEncoder {
         encoded.extend(protocol_data);
         encoded
     }
+
+    /// Encodes a selector string into its 4-byte representation.
     fn encode_executor_selector(&self, selector: &str) -> FixedBytes<4> {
         let hash = keccak256(selector.as_bytes());
         FixedBytes::<4>::from([hash[0], hash[1], hash[2], hash[3]])
     }
 
+    /// Uses prefix-length encoding to efficient encode action data.
+    ///
+    /// Prefix-length encoding is a data encoding method where the beginning of a data segment
+    /// (the "prefix") contains information about the length of the following data.
     fn ple_encode(&self, action_data_array: Vec<Vec<u8>>) -> Vec<u8> {
         let mut encoded_action_data: Vec<u8> = Vec::new();
 
@@ -57,7 +66,6 @@ pub trait EVMStrategyEncoder: StrategyEncoder {
 /// Represents the encoder for a swap strategy which supports single, sequential and split swaps.
 ///
 /// # Fields
-///
 /// * `swap_encoder_registry`: SwapEncoderRegistry, containing all possible swap encoders
 /// * `permit2`: Permit2, the object containing necessary information for managing permit2
 ///   operations
@@ -78,7 +86,9 @@ impl SplitSwapStrategyEncoder {
         Ok(Self { permit2: Permit2::new(signer_pk, chain)?, selector, swap_encoder_registry })
     }
 }
+
 impl EVMStrategyEncoder for SplitSwapStrategyEncoder {}
+
 impl StrategyEncoder for SplitSwapStrategyEncoder {
     fn encode_strategy(
         &self,
@@ -224,7 +234,6 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
 /// the router. Only one solution with one swap is supported.
 ///
 /// # Fields
-///
 /// * `swap_encoder_registry`: SwapEncoderRegistry, containing all possible swap encoders
 pub struct ExecutorStrategyEncoder {
     swap_encoder_registry: SwapEncoderRegistry,

src/encoding/evm/swap_encoder/builder.rs

@@ -4,6 +4,7 @@ use crate::encoding::{
     swap_encoder::SwapEncoder,
 };
 
+/// Builds a `SwapEncoder` for the given protocol system and executor address.
 pub struct SwapEncoderBuilder {
     protocol_system: String,
     executor_address: String,

src/encoding/evm/swap_encoder/swap_encoder_registry.rs

@@ -7,12 +7,16 @@ use crate::encoding::{
     swap_encoder::SwapEncoder,
 };
 
+/// Registry containing all supported `SwapEncoders`.
 #[derive(Clone)]
 pub struct SwapEncoderRegistry {
+    /// A hashmap containing the protocol system as a key and the `SwapEncoder` as a value.
     encoders: HashMap<String, Box<dyn SwapEncoder>>,
 }
 
 impl SwapEncoderRegistry {
+    /// Populates the registry with the `SwapEncoders` for the given blockchain by parsing the
+    /// executors in the file at the given path.
     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)?;

src/encoding/evm/tycho_encoder.rs

@@ -24,10 +24,10 @@ pub struct EVMTychoEncoder<S: StrategyEncoderRegistry> {
 }
 
 impl<S: StrategyEncoderRegistry> EVMTychoEncoder<S> {
-    pub fn new(strategy_selector: S, router_address: String) -> Result<Self, EncodingError> {
+    pub fn new(strategy_registry: S, router_address: String) -> Result<Self, EncodingError> {
         let router_address = Bytes::from_str(&router_address)
             .map_err(|_| EncodingError::FatalError("Invalid router address".to_string()))?;
-        Ok(EVMTychoEncoder { strategy_registry: strategy_selector, router_address })
+        Ok(EVMTychoEncoder { strategy_registry, router_address })
     }
 }
 
@@ -165,9 +165,9 @@ mod tests {
     }
 
     fn get_mocked_tycho_encoder() -> EVMTychoEncoder<MockStrategyRegistry> {
-        let strategy_selector = MockStrategyRegistry::new(Chain::Ethereum, "", None).unwrap();
+        let strategy_registry = MockStrategyRegistry::new(Chain::Ethereum, "", None).unwrap();
         EVMTychoEncoder::new(
-            strategy_selector,
+            strategy_registry,
             "0x1234567890abcdef1234567890abcdef12345678".to_string(),
         )
         .unwrap()

src/encoding/evm/utils.rs

@@ -16,11 +16,13 @@ pub fn bytes_to_address(address: &Bytes) -> Result<Address, EncodingError> {
     }
 }
 
+/// Converts a general `BigUint` to an EVM-specific `U256` value.
 pub fn biguint_to_u256(value: &BigUint) -> U256 {
     let bytes = value.to_bytes_be();
     U256::from_be_slice(&bytes)
 }
 
+/// Encodes the input data for a function call to the given function selector.
 pub fn encode_input(selector: &str, mut encoded_args: Vec<u8>) -> Vec<u8> {
     let mut hasher = Keccak256::new();
     hasher.update(selector.as_bytes());