feat: Transfer Optimizations in MaverickV2

- Also added integration test to test the optimizations, where we can see the in and out transfers being optimized if we enable verbose foundry testing
- Fixed typo in swap encoder builder initialization

src/encoding/evm/constants.rs

@@ -20,7 +20,7 @@ pub static GROUPABLE_PROTOCOLS: LazyLock<HashSet<&'static str>> = LazyLock::new(
 
 /// These protocols need an external in transfer to the pool. This transfer can be from the router,
 /// from the user or from the previous pool. Any protocols that are not defined here expect funds to
-/// be in the router at the time of swap and do the transfer themselves from msg.sender
+/// be in the router at the time of swap and do the transfer themselves from `msg.sender`
 pub static IN_TRANSFER_REQUIRED_PROTOCOLS: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
     let mut set = HashSet::new();
     set.insert("uniswap_v2");
@@ -30,6 +30,7 @@ pub static IN_TRANSFER_REQUIRED_PROTOCOLS: LazyLock<HashSet<&'static str>> = Laz
     set.insert("pancakeswap_v3");
     set.insert("uniswap_v4");
     set.insert("ekubo_v2");
+    set.insert("vm:maverick_v2");
     set
 });
 

src/encoding/evm/strategy_encoder/strategy_encoders.rs

@@ -2318,6 +2318,56 @@ mod tests {
             write_calldata_to_file("test_single_encoding_strategy_ekubo", hex_calldata.as_str());
         }
 
+        #[test]
+        fn test_single_encoding_strategy_maverick() {
+            // GHO -> (maverick) -> USDC
+            let maverick_pool = ProtocolComponent {
+                id: String::from("0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67"),
+                protocol_system: String::from("vm:maverick_v2"),
+                ..Default::default()
+            };
+            let token_in = Bytes::from("0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f");
+            let token_out = Bytes::from("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+            let swap = Swap {
+                component: maverick_pool,
+                token_in: token_in.clone(),
+                token_out: token_out.clone(),
+                split: 0f64,
+            };
+
+            let swap_encoder_registry = get_swap_encoder_registry();
+            let encoder = SingleSwapStrategyEncoder::new(
+                eth_chain(),
+                swap_encoder_registry,
+                None,
+                Bytes::from_str("0xA4AD4f68d0b91CFD19687c881e50f3A00242828c").unwrap(),
+                false,
+            )
+            .unwrap();
+
+            let solution = Solution {
+                exact_out: false,
+                given_token: token_in,
+                given_amount: BigUint::from_str("1_000000000000000000").unwrap(),
+                checked_token: token_out,
+                expected_amount: None,
+                checked_amount: Some(BigUint::from_str("1000").unwrap()),
+                slippage: None,
+                // Alice
+                sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
+                receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
+                swaps: vec![swap],
+                ..Default::default()
+            };
+
+            let (calldata, _) = encoder
+                .encode_strategy(solution)
+                .unwrap();
+
+            let hex_calldata = encode(&calldata);
+            write_calldata_to_file("test_single_encoding_strategy_maverick", hex_calldata.as_str());
+        }
+
         #[test]
         fn test_single_encoding_strategy_usv4_eth_in() {
             // Performs a single swap from ETH to PEPE using a USV4 pool

src/encoding/evm/swap_encoder/builder.rs

@@ -76,7 +76,7 @@ impl SwapEncoderBuilder {
             "vm:curve" => {
                 Ok(Box::new(CurveSwapEncoder::new(self.executor_address, self.chain, self.config)?))
             }
-            "vm::maverick_v2" => Ok(Box::new(MaverickV2SwapEncoder::new(
+            "vm:maverick_v2" => Ok(Box::new(MaverickV2SwapEncoder::new(
                 self.executor_address,
                 self.chain,
                 self.config,

src/encoding/evm/swap_encoder/swap_encoders.rs

@@ -620,6 +620,7 @@ impl SwapEncoder for MaverickV2SwapEncoder {
             bytes_to_address(&swap.token_in)?,
             component_id,
             bytes_to_address(&encoding_context.receiver)?,
+            (encoding_context.transfer_type as u8).to_be_bytes(),
         );
         Ok(args.abi_encode_packed())
     }
@@ -1545,6 +1546,7 @@ mod tests {
 
     #[test]
     fn test_encode_maverick_v2() {
+        // GHO -> (maverick) -> USDC
         let maverick_pool = ProtocolComponent {
             id: String::from("0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67"),
             protocol_system: String::from("vm:maverick_v2"),
@@ -1565,6 +1567,7 @@ mod tests {
             router_address: Some(Bytes::default()),
             group_token_in: token_in.clone(),
             group_token_out: token_out.clone(),
+            transfer_type: TransferType::TransferToProtocol,
         };
         let encoder = MaverickV2SwapEncoder::new(
             String::from("0x543778987b293C7E8Cf0722BB2e935ba6f4068D4"),
@@ -1587,6 +1590,8 @@ mod tests {
                 "14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67",
                 // receiver
                 "1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e",
+                // transfer from router to protocol
+                "00",
             ))
             .to_lowercase()
         );