feat: UniswapV3SwapEncoder

- No more supply owed action type or action data - we will always transfer from our router using a regular transfer in the callback.
- The receiver will always be sent with the actual swap call, meaning that no forward received action type or data is necessary either.
- We decode the pool fee as le-bytes and not be-bytes because that's how it's stored: 3c08359cf1/substreams/ethereum-uniswap-v3/src/modules/1_map_pool_created.rs (L64)

src/encoding/evm/swap_encoder/encoders.rs

@@ -70,6 +70,84 @@ impl SwapEncoder for UniswapV2SwapEncoder {
     }
 }
 
+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_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 v3: {}",
+                    swap.component.id
+                ))
+            })?,
+        );
+        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)?,
+            bytes_to_address(&component_id)?,
+            zero_for_one,
+            encoding_context.exact_out,
+        );
+
+        Ok(args.abi_encode_packed())
+    }
+
+    fn executor_address(&self) -> &str {
+        &self.executor_address
+    }
+}
+
 pub struct BalancerV2SwapEncoder {
     executor_address: String,
     vault_address: String,
@@ -116,6 +194,8 @@ impl SwapEncoder for BalancerV2SwapEncoder {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
     use alloy::hex::encode;
     use tycho_core::{dto::ProtocolComponent, Bytes};
 
@@ -159,6 +239,53 @@ mod tests {
             ))
         );
     }
+    #[tokio::test]
+    async 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() {