diff --git a/CHANGELOG.md b/CHANGELOG.md index 98553bb..874b976 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,23 @@ +## [0.33.0](https://github.com/propeller-heads/tycho-execution/compare/0.32.0...0.33.0) (2025-02-06) + + +### Features + +* Get native/wrapped addresses from chain ([8cd7d9f](https://github.com/propeller-heads/tycho-execution/commit/8cd7d9f76e0b68bbf71f61bc56ab60a5e5693327)) +* Take Chain object containing native/wrapped addresses ([e83b8d9](https://github.com/propeller-heads/tycho-execution/commit/e83b8d9aef130839dd88355e110172e1377bad80)) + + +### Bug Fixes + +* Do not let user specify the native/wrapped token ([1a07c7d](https://github.com/propeller-heads/tycho-execution/commit/1a07c7dc61ff7f86739ba7fbde2e7a42ebdf284f)) + +## [0.32.0](https://github.com/propeller-heads/tycho-execution/compare/0.31.0...0.32.0) (2025-02-06) + + +### Features + +* Accept any struct that implements Into in Swap ([cb14022](https://github.com/propeller-heads/tycho-execution/commit/cb140226814add4f8141f3ad36784379a80d656c)) + ## [0.31.0](https://github.com/propeller-heads/tycho-execution/compare/0.30.1...0.31.0) (2025-02-05) diff --git a/Cargo.lock b/Cargo.lock index 21b6199..829efb8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4231,7 +4231,7 @@ dependencies = [ [[package]] name = "tycho-execution" -version = "0.31.0" +version = "0.33.0" dependencies = [ "alloy", "alloy-primitives", @@ -4242,6 +4242,7 @@ dependencies = [ "lazy_static", "num-bigint", "num-traits", + "once_cell", "rstest", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index 8a363ac..9db5661 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tycho-execution" -version = "0.31.0" +version = "0.33.0" edition = "2021" [dependencies] @@ -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" diff --git a/examples/quickstart/main.rs b/examples/quickstart/main.rs index bef3e1a..f63cd19 100644 --- a/examples/quickstart/main.rs +++ b/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,12 @@ fn main() { .expect("Failed to create user address"); let executors_file_path = "src/encoding/config/executor_addresses.json"; + let eth_chain = Chain::from(TychoCoreChain::Ethereum); // 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) + let encoder = EVMTychoEncoder::new(strategy_encoder_registry, router_address, eth_chain) .expect("Failed to create encoder"); // ------------------- Encode a simple swap ------------------- diff --git a/src/encoding/evm/approvals/permit2.rs b/src/encoding/evm/approvals/permit2.rs index b189d08..c118358 100644 --- a/src/encoding/evm/approvals/permit2.rs +++ b/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 { - 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, }) } @@ -165,6 +164,7 @@ mod tests { use alloy_primitives::Uint; use num_bigint::BigUint; + use tycho_core::dto::Chain as TychoCoreChain; use super::*; @@ -199,11 +199,15 @@ mod tests { } } + fn eth_chain() -> Chain { + TychoCoreChain::Ethereum.into() + } + #[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 +227,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 +268,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); diff --git a/src/encoding/evm/constants.rs b/src/encoding/evm/constants.rs deleted file mode 100644 index f0fa47d..0000000 --- a/src/encoding/evm/constants.rs +++ /dev/null @@ -1,10 +0,0 @@ -use alloy_primitives::hex; -use lazy_static::lazy_static; -use tycho_core::Bytes; - -lazy_static! { - pub static ref NATIVE_ADDRESS: Bytes = - Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()); - pub static ref WETH_ADDRESS: Bytes = - Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec()); -} diff --git a/src/encoding/evm/mod.rs b/src/encoding/evm/mod.rs index 543ed21..9c736bb 100644 --- a/src/encoding/evm/mod.rs +++ b/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; diff --git a/src/encoding/evm/models.rs b/src/encoding/evm/models.rs deleted file mode 100644 index 706bc46..0000000 --- a/src/encoding/evm/models.rs +++ /dev/null @@ -1,20 +0,0 @@ -use tycho_core::dto::Chain; - -pub struct ChainId(u64); - -impl ChainId { - pub fn id(&self) -> u64 { - self.0 - } -} - -impl From 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), - } - } -} diff --git a/src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs b/src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs index 08ac5f5..8ca10ce 100644 --- a/src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs +++ b/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}, }; @@ -27,7 +25,7 @@ impl StrategyEncoderRegistry for EVMStrategyEncoderRegistry { executors_file_path: &str, signer_pk: Option, ) -> Result { - 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> = HashMap::new(); strategies.insert( diff --git a/src/encoding/evm/strategy_encoder/strategy_encoders.rs b/src/encoding/evm/strategy_encoder/strategy_encoders.rs index 1c429cb..f1e81df 100644 --- a/src/encoding/evm/strategy_encoder/strategy_encoders.rs +++ b/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, WETH_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, }; @@ -78,6 +77,8 @@ pub struct SplitSwapStrategyEncoder { swap_encoder_registry: SwapEncoderRegistry, permit2: Permit2, selector: String, + native_address: Bytes, + wrapped_address: Bytes, } impl SplitSwapStrategyEncoder { @@ -87,7 +88,13 @@ impl SplitSwapStrategyEncoder { swap_encoder_registry: SwapEncoderRegistry, ) -> Result { let selector = "swap(uint256,address,address,uint256,bool,bool,uint256,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)".to_string(); - Ok(Self { permit2: Permit2::new(signer_pk, chain)?, selector, swap_encoder_registry }) + Ok(Self { + permit2: Permit2::new(signer_pk, chain.clone())?, + selector, + swap_encoder_registry, + native_address: chain.native_token()?, + wrapped_address: chain.wrapped_token()?, + }) } /// Raises an error if the split percentages are invalid. @@ -182,18 +189,18 @@ impl SplitSwapStrategyEncoder { native_action: &Option, ) -> Result<(), EncodingError> { // Convert ETH to WETH only if there's a corresponding wrap/unwrap action - let given_token = if *given_token == *NATIVE_ADDRESS { + let given_token = if *given_token == *self.native_address { match native_action { - Some(NativeAction::Wrap) => &WETH_ADDRESS, + Some(NativeAction::Wrap) => &self.wrapped_address, _ => given_token, } } else { given_token }; - let checked_token = if *checked_token == *NATIVE_ADDRESS { + let checked_token = if *checked_token == *self.native_address { match native_action { - Some(NativeAction::Unwrap) => &WETH_ADDRESS, + Some(NativeAction::Unwrap) => &self.wrapped_address, _ => checked_token, } } else { @@ -310,14 +317,14 @@ impl StrategyEncoder for SplitSwapStrategyEncoder { let mut tokens = Vec::with_capacity(2 + intermediary_tokens.len()); if wrap { - tokens.push(WETH_ADDRESS.clone()); + tokens.push(self.wrapped_address.clone()); } else { tokens.push(solution.given_token.clone()); } tokens.extend(intermediary_tokens); if unwrap { - tokens.push(WETH_ADDRESS.clone()); + tokens.push(self.wrapped_address.clone()); } else { tokens.push(solution.checked_token.clone()); } @@ -459,19 +466,32 @@ 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 super::*; - use crate::encoding::{ - evm::constants::{NATIVE_ADDRESS, WETH_ADDRESS}, - models::Swap, + use tycho_core::{ + dto::{Chain as TychoCoreChain, ProtocolComponent}, + Bytes, }; + use super::*; + use crate::encoding::models::Swap; + + fn eth_chain() -> Chain { + TychoCoreChain::Ethereum.into() + } + + fn eth() -> Bytes { + Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()) + } + + fn weth() -> Bytes { + Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec()) + } + fn get_swap_encoder_registry() -> SwapEncoderRegistry { - SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", Chain::Ethereum) - .unwrap() + let eth_chain = eth_chain(); + SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", eth_chain).unwrap() } #[test] @@ -479,7 +499,7 @@ mod tests { let swap_encoder_registry = get_swap_encoder_registry(); let encoder = ExecutorStrategyEncoder::new(swap_encoder_registry); - let token_in = Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"); + let token_in = weth(); let token_out = Bytes::from("0x6b175474e89094c44da98b954eedeac495271d0f"); let swap = Swap { @@ -585,8 +605,7 @@ mod tests { }; let swap_encoder_registry = get_swap_encoder_registry(); let encoder = - SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry) - .unwrap(); + SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap(); let solution = Solution { exact_out: false, given_token: weth, @@ -681,17 +700,16 @@ mod tests { protocol_system: "uniswap_v2".to_string(), ..Default::default() }, - token_in: WETH_ADDRESS.clone(), + token_in: weth(), token_out: dai.clone(), split: 0f64, }; let swap_encoder_registry = get_swap_encoder_registry(); let encoder = - SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry) - .unwrap(); + SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap(); let solution = Solution { exact_out: false, - given_token: NATIVE_ADDRESS.clone(), + given_token: eth(), given_amount: BigUint::from_str("1_000000000000000000").unwrap(), checked_token: dai, expected_amount: Some(BigUint::from_str("3_000_000000000000000000").unwrap()), @@ -731,18 +749,17 @@ mod tests { ..Default::default() }, token_in: dai.clone(), - token_out: WETH_ADDRESS.clone(), + token_out: weth(), split: 0f64, }; let swap_encoder_registry = get_swap_encoder_registry(); let encoder = - SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry) - .unwrap(); + SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap(); let solution = Solution { exact_out: false, given_token: dai, given_amount: BigUint::from_str("3_000_000000000000000000").unwrap(), - checked_token: NATIVE_ADDRESS.clone(), + checked_token: eth(), expected_amount: Some(BigUint::from_str("1_000000000000000000").unwrap()), check_amount: None, sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(), @@ -777,7 +794,7 @@ mod tests { let private_key = "0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string(); - let weth = Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap(); + let weth = weth(); let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap(); let wbtc = Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599").unwrap(); let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap(); @@ -826,8 +843,7 @@ mod tests { }; let swap_encoder_registry = get_swap_encoder_registry(); let encoder = - SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry) - .unwrap(); + SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap(); let solution = Solution { exact_out: false, given_token: weth, @@ -854,7 +870,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] diff --git a/src/encoding/evm/swap_encoder/swap_encoder_registry.rs b/src/encoding/evm/swap_encoder/swap_encoder_registry.rs index 83126c8..a9bb22f 100644 --- a/src/encoding/evm/swap_encoder/swap_encoder_registry.rs +++ b/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, }; @@ -19,10 +17,10 @@ impl SwapEncoderRegistry { /// executors' addresses in the file at the given path. pub fn new(executors_file_path: &str, blockchain: Chain) -> Result { let config_str = fs::read_to_string(executors_file_path)?; - let config: HashMap> = serde_json::from_str(&config_str)?; + let config: HashMap> = 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); diff --git a/src/encoding/evm/tycho_encoder.rs b/src/encoding/evm/tycho_encoder.rs index 5cd5d5e..a022d18 100644 --- a/src/encoding/evm/tycho_encoder.rs +++ b/src/encoding/evm/tycho_encoder.rs @@ -5,8 +5,7 @@ use tycho_core::Bytes; use crate::encoding::{ errors::EncodingError, - evm::constants::{NATIVE_ADDRESS, WETH_ADDRESS}, - models::{NativeAction, Solution, Transaction}, + models::{Chain, NativeAction, Solution, Transaction}, strategy_encoder::StrategyEncoderRegistry, tycho_encoder::TychoEncoder, }; @@ -18,16 +17,34 @@ use crate::encoding::{ /// * `strategy_registry`: S, the strategy registry to use to select the best strategy to encode a /// solution, based on its supported strategies and the solution attributes. /// * `router_address`: Bytes, the address of the router to use to execute the swaps. +/// * `native_address`: Address of the chain's native token +/// * `wrapped_address`: Address of the chain's wrapped native token pub struct EVMTychoEncoder { strategy_registry: S, router_address: Bytes, + native_address: Bytes, + wrapped_address: Bytes, } impl EVMTychoEncoder { - pub fn new(strategy_registry: S, router_address: String) -> Result { + pub fn new( + strategy_registry: S, + router_address: String, + chain: Chain, + ) -> Result { let router_address = Bytes::from_str(&router_address) .map_err(|_| EncodingError::FatalError("Invalid router address".to_string()))?; - Ok(EVMTychoEncoder { strategy_registry, router_address }) + if chain.name != *"ethereum" { + return Err(EncodingError::InvalidInput( + "Currently only Ethereum is supported".to_string(), + )); + } + Ok(EVMTychoEncoder { + strategy_registry, + router_address, + native_address: chain.native_token()?, + wrapped_address: chain.wrapped_token()?, + }) } } @@ -52,28 +69,30 @@ impl EVMTychoEncoder { } if let Some(native_action) = solution.clone().native_action { if native_action == NativeAction::Wrap { - if solution.given_token != *NATIVE_ADDRESS { + if solution.given_token != self.native_address { return Err(EncodingError::FatalError( - "ETH must be the input token in order to wrap".to_string(), + "Native token must be the input token in order to wrap".to_string(), )); } if let Some(first_swap) = solution.swaps.first() { - if first_swap.token_in != *WETH_ADDRESS { + if first_swap.token_in != self.wrapped_address { return Err(EncodingError::FatalError( - "WETH must be the first swap's input in order to wrap".to_string(), + "Wrapped token must be the first swap's input in order to wrap" + .to_string(), )); } } } else if native_action == NativeAction::Unwrap { - if solution.checked_token != *NATIVE_ADDRESS { + if solution.checked_token != self.native_address { return Err(EncodingError::FatalError( - "ETH must be the output token in order to unwrap".to_string(), + "Native token must be the output token in order to unwrap".to_string(), )); } if let Some(last_swap) = solution.swaps.last() { - if last_swap.token_out != *WETH_ADDRESS { + if last_swap.token_out != self.wrapped_address { return Err(EncodingError::FatalError( - "WETH must be the last swap's output in order to unwrap".to_string(), + "Wrapped token must be the last swap's output in order to unwrap" + .to_string(), )); } } @@ -120,7 +139,7 @@ impl TychoEncoder for EVMTychoEncoder { #[cfg(test)] mod tests { - use tycho_core::dto::{Chain, ProtocolComponent}; + use tycho_core::dto::{Chain as TychoCoreChain, ProtocolComponent}; use super::*; use crate::encoding::{ @@ -131,10 +150,22 @@ mod tests { strategy: Box, } + fn eth_chain() -> Chain { + TychoCoreChain::Ethereum.into() + } + fn dai() -> Bytes { Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap() } + fn eth() -> Bytes { + Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap() + } + + fn weth() -> Bytes { + Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap() + } + impl StrategyEncoderRegistry for MockStrategyRegistry { fn new( _chain: Chain, @@ -174,10 +205,11 @@ mod tests { } fn get_mocked_tycho_encoder() -> EVMTychoEncoder { - let strategy_registry = MockStrategyRegistry::new(Chain::Ethereum, "", None).unwrap(); + let strategy_registry = MockStrategyRegistry::new(eth_chain(), "", None).unwrap(); EVMTychoEncoder::new( strategy_registry, "0x1234567890abcdef1234567890abcdef12345678".to_string(), + eth_chain(), ) .unwrap() } @@ -192,7 +224,7 @@ mod tests { protocol_system: "uniswap_v2".to_string(), ..Default::default() }, - token_in: WETH_ADDRESS.clone(), + token_in: weth(), token_out: dai(), split: 0f64, }; @@ -200,7 +232,7 @@ mod tests { let solution = Solution { exact_out: false, given_amount: eth_amount_in.clone(), - given_token: NATIVE_ADDRESS.clone(), + given_token: eth(), router_address: None, swaps: vec![swap], native_action: Some(NativeAction::Wrap), @@ -244,14 +276,14 @@ mod tests { protocol_system: "uniswap_v2".to_string(), ..Default::default() }, - token_in: WETH_ADDRESS.clone(), + token_in: weth(), token_out: dai(), split: 0f64, }; let solution = Solution { exact_out: false, - given_token: NATIVE_ADDRESS.clone(), + given_token: eth(), checked_token: dai(), check_amount: None, swaps: vec![swap], @@ -273,14 +305,14 @@ mod tests { protocol_system: "uniswap_v2".to_string(), ..Default::default() }, - token_in: WETH_ADDRESS.clone(), + token_in: weth(), token_out: dai(), split: 0f64, }; let solution = Solution { exact_out: false, - given_token: WETH_ADDRESS.clone(), + given_token: weth(), swaps: vec![swap], native_action: Some(NativeAction::Wrap), ..Default::default() @@ -291,7 +323,9 @@ mod tests { assert!(result.is_err()); assert_eq!( result.err().unwrap(), - EncodingError::FatalError("ETH must be the input token in order to wrap".to_string()) + EncodingError::FatalError( + "Native token must be the input token in order to wrap".to_string() + ) ); } @@ -304,14 +338,14 @@ mod tests { protocol_system: "uniswap_v2".to_string(), ..Default::default() }, - token_in: NATIVE_ADDRESS.clone(), + token_in: eth(), token_out: dai(), split: 0f64, }; let solution = Solution { exact_out: false, - given_token: NATIVE_ADDRESS.clone(), + given_token: eth(), swaps: vec![swap], native_action: Some(NativeAction::Wrap), ..Default::default() @@ -323,7 +357,7 @@ mod tests { assert_eq!( result.err().unwrap(), EncodingError::FatalError( - "WETH must be the first swap's input in order to wrap".to_string() + "Wrapped token must be the first swap's input in order to wrap".to_string() ) ); } @@ -333,7 +367,7 @@ mod tests { let encoder = get_mocked_tycho_encoder(); let solution = Solution { exact_out: false, - given_token: NATIVE_ADDRESS.clone(), + given_token: eth(), swaps: vec![], native_action: Some(NativeAction::Wrap), ..Default::default() @@ -358,13 +392,13 @@ mod tests { ..Default::default() }, token_in: dai(), - token_out: WETH_ADDRESS.clone(), + token_out: weth(), split: 0f64, }; let solution = Solution { exact_out: false, - checked_token: NATIVE_ADDRESS.clone(), + checked_token: eth(), check_amount: None, swaps: vec![swap], native_action: Some(NativeAction::Unwrap), @@ -386,14 +420,14 @@ mod tests { ..Default::default() }, token_in: dai(), - token_out: WETH_ADDRESS.clone(), + token_out: weth(), split: 0f64, }; let solution = Solution { exact_out: false, given_token: dai(), - checked_token: WETH_ADDRESS.clone(), + checked_token: weth(), swaps: vec![swap], native_action: Some(NativeAction::Unwrap), ..Default::default() @@ -405,7 +439,7 @@ mod tests { assert_eq!( result.err().unwrap(), EncodingError::FatalError( - "ETH must be the output token in order to unwrap".to_string() + "Native token must be the output token in order to unwrap".to_string() ) ); } @@ -420,13 +454,13 @@ mod tests { ..Default::default() }, token_in: dai(), - token_out: NATIVE_ADDRESS.clone(), + token_out: eth(), split: 0f64, }; let solution = Solution { exact_out: false, - checked_token: NATIVE_ADDRESS.clone(), + checked_token: eth(), swaps: vec![swap], native_action: Some(NativeAction::Unwrap), ..Default::default() @@ -438,7 +472,7 @@ mod tests { assert_eq!( result.err().unwrap(), EncodingError::FatalError( - "WETH must be the last swap's output in order to unwrap".to_string() + "Wrapped token must be the last swap's output in order to unwrap".to_string() ) ); } diff --git a/src/encoding/models.rs b/src/encoding/models.rs index 5cd5707..3aa278f 100644 --- a/src/encoding/models.rs +++ b/src/encoding/models.rs @@ -1,5 +1,11 @@ +use hex; use num_bigint::BigUint; -use tycho_core::{dto::ProtocolComponent, Bytes}; +use tycho_core::{ + dto::{Chain as TychoCoreChain, ProtocolComponent}, + Bytes, +}; + +use crate::encoding::errors::EncodingError; /// Represents a solution containing details describing an order, and instructions for filling /// the order. @@ -61,6 +67,17 @@ pub struct Swap { pub split: f64, } +impl Swap { + pub fn new>( + component: T, + token_in: Bytes, + token_out: Bytes, + split: f64, + ) -> Self { + Self { component: component.into(), token_in, token_out, split } + } +} + /// Represents a transaction to be executed. /// /// # Fields @@ -86,3 +103,99 @@ 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, +} + +impl ChainId { + pub fn id(&self) -> u64 { + self.0 + } +} + +impl From 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 From for Chain { + fn from(chain: TychoCoreChain) -> Self { + Chain { id: chain.into(), name: chain.to_string() } + } +} + +impl Chain { + pub fn native_token(&self) -> Result { + match self.id.id() { + 1 => Ok(Bytes::from(hex::decode("0000000000000000000000000000000000000000").map_err( + |_| EncodingError::FatalError("Failed to decode native token".to_string()), + )?)), + _ => Err(EncodingError::InvalidInput(format!( + "Native token not set for chain {:?}. Double check the chain is supported.", + self.name + ))), + } + } + pub fn wrapped_token(&self) -> Result { + match self.id.id() { + 1 => Ok(Bytes::from(hex::decode("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").map_err( + |_| EncodingError::FatalError("Failed to decode wrapped token".to_string()), + )?)), + _ => Err(EncodingError::InvalidInput(format!( + "Wrapped token not set for chain {:?}. Double check the chain is supported.", + self.name + ))), + } + } +} + +mod tests { + use super::*; + + struct MockProtocolComponent { + id: String, + protocol_system: String, + } + + impl From for ProtocolComponent { + fn from(component: MockProtocolComponent) -> Self { + ProtocolComponent { + id: component.id, + protocol_system: component.protocol_system, + tokens: vec![], + protocol_type_name: "".to_string(), + chain: Default::default(), + contract_ids: vec![], + static_attributes: Default::default(), + change: Default::default(), + creation_tx: Default::default(), + created_at: Default::default(), + } + } + } + + #[test] + fn test_swap_new() { + let component = MockProtocolComponent { + id: "i-am-an-id".to_string(), + protocol_system: "uniswap_v2".to_string(), + }; + let swap = Swap::new(component, Bytes::from("0x12"), Bytes::from("34"), 0.5); + assert_eq!(swap.token_in, Bytes::from("0x12")); + assert_eq!(swap.token_out, Bytes::from("0x34")); + assert_eq!(swap.component.protocol_system, "uniswap_v2"); + assert_eq!(swap.component.id, "i-am-an-id"); + } +} diff --git a/src/encoding/strategy_encoder.rs b/src/encoding/strategy_encoder.rs index 032c993..bb7ecf4 100644 --- a/src/encoding/strategy_encoder.rs +++ b/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, +}; /// Encodes a solution using a specific strategy. pub trait StrategyEncoder {