Merge branch 'main' into router/hr/ENG-4035-Balancer-V2-Executor

src/encoding/evm/swap_encoder/encoders.rs

@@ -1,9 +1,7 @@
 use std::str::FromStr;
-
 use alloy::hex::decode;
 use alloy_primitives::{Address, Bytes as AlloyBytes};
 use alloy_sol_types::SolValue;
-use tycho_core::Bytes;
 
 use crate::encoding::{
     errors::EncodingError,
@@ -37,28 +35,84 @@ impl SwapEncoder for UniswapV2SwapEncoder {
         let token_in_address = bytes_to_address(&swap.token_in)?;
         let token_out_address = bytes_to_address(&swap.token_out)?;
 
-        let zero_for_one = Self::get_zero_to_one(token_in_address, token_out_address);
-        let component_id = Bytes::from(
-            decode(
-                swap.component
-                    .id
-                    .trim_start_matches("0x"),
-            )
-            .map_err(|_| {
-                EncodingError::FatalError(format!(
-                    "Failed to parse component id for Uniswap v2: {}",
-                    swap.component.id
-                ))
-            })?,
-        );
+        let zero_to_one = Self::get_zero_to_one(token_in_address, token_out_address);
+        let component_id = Address::from_str(&swap.component.id)
+            .map_err(|_| EncodingError::FatalError("Invalid USV2 component id".to_string()))?;
 
         // Token in address is always needed to perform a manual transfer from the router,
         // since no optimizations are performed that send from one pool to the next
         let args = (
             token_in_address,
-            bytes_to_address(&component_id)?,
+            component_id,
             bytes_to_address(&encoding_context.receiver)?,
-            zero_for_one,
+            zero_to_one,
+            encoding_context.exact_out,
+        );
+
+        Ok(args.abi_encode_packed())
+    }
+
+    fn executor_address(&self) -> &str {
+        &self.executor_address
+    }
+}
+
+pub struct UniswapV3SwapEncoder {
+    executor_address: String,
+}
+
+impl UniswapV3SwapEncoder {
+    fn get_zero_to_one(sell_token_address: Address, buy_token_address: Address) -> bool {
+        sell_token_address < buy_token_address
+    }
+}
+
+impl SwapEncoder for UniswapV3SwapEncoder {
+    fn new(executor_address: String) -> Self {
+        Self { executor_address }
+    }
+
+    fn encode_swap(
+        &self,
+        swap: Swap,
+        encoding_context: EncodingContext,
+    ) -> Result<Vec<u8>, EncodingError> {
+        let token_in_address = bytes_to_address(&swap.token_in)?;
+        let token_out_address = bytes_to_address(&swap.token_out)?;
+
+        let zero_to_one = Self::get_zero_to_one(token_in_address, token_out_address);
+        let component_id = Address::from_str(&swap.component.id)
+            .map_err(|_| EncodingError::FatalError("Invalid USV3 component id".to_string()))?;
+        let mut pool_fee_bytes = swap
+            .component
+            .static_attributes
+            .get("pool_fee")
+            .ok_or_else(|| {
+                EncodingError::FatalError(
+                    "Pool fee not found in Uniswap v3 static attributes".to_string(),
+                )
+            })?
+            .as_ref()
+            .to_vec();
+
+        // Reverse to get be bytes, since this is encoded as le bytes
+        pool_fee_bytes.reverse();
+
+        let pool_fee_u24: [u8; 3] = pool_fee_bytes[pool_fee_bytes.len() - 3..]
+            .try_into()
+            .map_err(|_| {
+                EncodingError::FatalError(
+                    "Pool fee static attribute must be at least 3 bytes".to_string(),
+                )
+            })?;
+
+        let args = (
+            token_in_address,
+            token_out_address,
+            pool_fee_u24,
+            bytes_to_address(&encoding_context.receiver)?,
+            component_id,
+            zero_to_one,
             encoding_context.exact_out,
         );
 
@@ -118,6 +172,8 @@ impl SwapEncoder for BalancerV2SwapEncoder {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
     use alloy::hex::encode;
     use tycho_core::{dto::ProtocolComponent, Bytes};
 
@@ -161,6 +217,53 @@ mod tests {
             ))
         );
     }
+    #[test]
+    fn test_encode_uniswap_v3() {
+        let encoded_pool_fee: [u8; 4] = 500u32.to_le_bytes();
+        let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
+        static_attributes.insert("pool_fee".into(), Bytes::from(encoded_pool_fee[..3].to_vec()));
+
+        let usv3_pool = ProtocolComponent {
+            id: String::from("0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640"),
+            static_attributes,
+            ..Default::default()
+        };
+        let swap = Swap {
+            component: usv3_pool,
+            token_in: Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"),
+            token_out: Bytes::from("0x6b175474e89094c44da98b954eedeac495271d0f"),
+            split: 0f64,
+        };
+        let encoding_context = EncodingContext {
+            receiver: Bytes::from("0x0000000000000000000000000000000000000001"),
+            exact_out: false,
+            router_address: Bytes::zero(20),
+        };
+        let encoder = UniswapV3SwapEncoder::new(String::from("0x"));
+        let encoded_swap = encoder
+            .encode_swap(swap, encoding_context)
+            .unwrap();
+        let hex_swap = encode(&encoded_swap);
+        assert_eq!(
+            hex_swap,
+            String::from(concat!(
+                // in token
+                "c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                // out token
+                "6b175474e89094c44da98b954eedeac495271d0f",
+                // fee
+                "0001f4",
+                // receiver
+                "0000000000000000000000000000000000000001",
+                // pool id
+                "88e6a0c2ddd26feeb64f039a2c41296fcb3f5640",
+                // zero for one
+                "00",
+                // exact out
+                "00",
+            ))
+        );
+    }
 
     #[test]
     fn test_encode_balancer_v2() {