Liquidity.Party/tycho-execution
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: merge main

Browse Source
This commit is contained in:
TAMARA LIPOWSKI
2025-02-06 11:49:17 -05:00
parent 2b94a3f213 54ef671683
commit 9adbab498c
14 changed files with 281 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/encoding/evm/approvals/permit2.rs
View File

@@ -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<Self, EncodingError> {
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);

10
src/encoding/evm/constants.rs
View File

@@ -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());
}

2
src/encoding/evm/mod.rs
View File

@@ -1,6 +1,4 @@
pub mod approvals;
mod constants;
mod models;
pub mod strategy_encoder;
mod swap_encoder;
pub mod tycho_encoder;

20
src/encoding/evm/models.rs
View File

@@ -1,20 +0,0 @@
use tycho_core::dto::Chain;
pub struct ChainId(u64);
impl ChainId {
pub fn id(&self) -> u64 {
self.0
}
}
impl From<Chain> 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),
}
}
}

6
src/encoding/evm/strategy_encoder/strategy_encoder_registry.rs
View File

@@ -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<String>,
) -> Result<Self, EncodingError> {
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<String, Box<dyn StrategyEncoder>> = HashMap::new();
strategies.insert(

82
src/encoding/evm/strategy_encoder/strategy_encoders.rs
View File

@@ -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<Self, EncodingError> {
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<NativeAction>,
) -> 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]

8
src/encoding/evm/swap_encoder/swap_encoder_registry.rs
View File

@@ -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<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)?;
let config: HashMap<String, HashMap<String, String>> = 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);

100
src/encoding/evm/tycho_encoder.rs
View File

@@ -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<S: StrategyEncoderRegistry> {
strategy_registry: S,
router_address: Bytes,
native_address: Bytes,
wrapped_address: Bytes,
}
impl<S: StrategyEncoderRegistry> EVMTychoEncoder<S> {
pub fn new(strategy_registry: S, router_address: String) -> Result<Self, EncodingError> {
pub fn new(
strategy_registry: S,
router_address: String,
chain: Chain,
) -> Result<Self, EncodingError> {
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<S: StrategyEncoderRegistry> EVMTychoEncoder<S> {
}
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<S: StrategyEncoderRegistry> TychoEncoder<S> for EVMTychoEncoder<S> {
#[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<dyn StrategyEncoder>,
}
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<MockStrategyRegistry> {
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()
)
);
}