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

refactor: Make group_swaps a util method

Browse Source 
- In preparation for also using this for the executor encoder.
This also make test setup much easier for swap grouping - not having to init the encoder every time.
This commit is contained in:
TAMARA LIPOWSKI
2025-02-18 12:12:08 -05:00
parent 4f37cd392b
commit 962e460e34
3 changed files with 326 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -8,15 +8,14 @@ use crate::encoding::{
errors::EncodingError,
evm::{
approvals::permit2::Permit2,
constants::GROUPABLE_PROTOCOLS,
strategy_encoder::strategy_validators::SplitSwapValidator,
strategy_encoder::{strategy_validators::SplitSwapValidator, utils::group_swaps},
swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
utils::{
biguint_to_u256, bytes_to_address, encode_input, get_min_amount_for_solution,
get_token_position, percentage_to_uint24,
},
},
models::{Chain, EncodingContext, NativeAction, Solution, Swap},
models::{Chain, EncodingContext, NativeAction, Solution},
strategy_encoder::StrategyEncoder,
swap_encoder::SwapEncoder,
};
@@ -66,24 +65,6 @@ pub trait EVMStrategyEncoder: StrategyEncoder {
}
}
/// Represents a group of swaps that can be encoded into a single swap execution for gas
/// optimization.
///
/// # Fields
/// * `input_token`: Bytes, the input token of the first swap
/// * `output_token`: Bytes, the output token of the final swap
/// * `protocol_system`: String, the protocol system of the swaps
/// * `swaps`: Vec<Swap>, the sequence of swaps to be executed as a group
/// * `split`: f64, the split percentage of the first swap in the group
#[derive(Clone, PartialEq, Debug)]
pub struct SwapGroup {
input_token: Bytes,
output_token: Bytes,
protocol_system: String,
swaps: Vec<Swap>,
split: f64,
}
/// Represents the encoder for a swap strategy which supports single, sequential and split swaps.
///
/// # Fields
@@ -121,55 +102,6 @@ impl SplitSwapStrategyEncoder {
split_swap_validator: SplitSwapValidator,
})
}
/// Group consecutive swaps which can be encoded into one swap execution for gas optimization.
///
/// An example where this applies is the case of USV4, which uses a PoolManager contract
/// to save token transfers on consecutive swaps.
fn group_swaps(&self, swaps: Vec<Swap>) -> Vec<SwapGroup> {
let mut grouped_swaps: Vec<SwapGroup> = Vec::new();
let mut current_group: Option<SwapGroup> = None;
let mut last_swap_protocol = "".to_string();
let mut groupable_protocol;
let mut last_swap_out_token = Bytes::default();
for swap in swaps {
let current_swap_protocol = swap.component.protocol_system.clone();
groupable_protocol = GROUPABLE_PROTOCOLS.contains(&current_swap_protocol.as_str());
// Split 0 can also mean that the swap is the remaining part of a branch of splits,
// so we need to check the last swap's out token as well
let no_split = swap.split == 0.0 && swap.token_in == last_swap_out_token;
if current_swap_protocol == last_swap_protocol && groupable_protocol && no_split {
// Second or later groupable pool in a sequence of groupable pools. Merge to the
// current group.
if let Some(group) = current_group.as_mut() {
group.swaps.push(swap.clone());
// Update the output token of the current group.
group.output_token = swap.token_out.clone();
}
} else {
// Not second or later USV4 pool. Push the current group (if it exists) and then
// create a new group.
if let Some(group) = current_group.as_mut() {
grouped_swaps.push(group.clone());
}
current_group = Some(SwapGroup {
input_token: swap.token_in.clone(),
output_token: swap.token_out.clone(),
protocol_system: current_swap_protocol.clone(),
swaps: vec![swap.clone()],
split: swap.split,
});
}
last_swap_protocol = current_swap_protocol;
last_swap_out_token = swap.token_out.clone();
}
if let Some(group) = current_group.as_mut() {
grouped_swaps.push(group.clone());
}
grouped_swaps
}
}
impl EVMStrategyEncoder for SplitSwapStrategyEncoder {}
@@ -204,7 +136,7 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
.into_iter()
.collect();
let grouped_swaps = self.group_swaps(solution.swaps);
let grouped_swaps = group_swaps(solution.swaps);
let intermediary_tokens: HashSet<Bytes> = grouped_swaps
.iter()
@@ -778,262 +710,6 @@ mod tests {
println!("{}", _hex_calldata);
}
#[test]
fn test_group_swaps_simple() {
// The first and second swaps can be grouped since there is no split, and they are
// both USV4.
//
// WETH ──(USV4)──> WBTC ───(USV4)──> USDC ───(USV2)──> DAI
//
// Set up a mock private key for signing
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let weth = weth();
let wbtc = Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599").unwrap();
let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
let swap_weth_wbtc = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: wbtc.clone(),
// This represents the remaining 50%, but to avoid any rounding errors we set this to
// 0 to signify "the remainder of the WETH value". It should still be very close to 50%
split: 0f64,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let swap_usdc_dai = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: usdc.clone(),
token_out: dai.clone(),
split: 0f64,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let grouped_swaps = encoder.group_swaps(vec![
swap_weth_wbtc.clone(),
swap_wbtc_usdc.clone(),
swap_usdc_dai.clone(),
]);
assert_eq!(
grouped_swaps,
vec![
SwapGroup {
swaps: vec![swap_weth_wbtc, swap_wbtc_usdc],
input_token: weth,
output_token: usdc.clone(),
protocol_system: "uniswap_v4".to_string(),
split: 0f64,
},
SwapGroup {
swaps: vec![swap_usdc_dai],
input_token: usdc,
output_token: dai,
protocol_system: "uniswap_v2".to_string(),
split: 0f64,
}
]
);
}
#[test]
fn test_group_swaps_complex_split() {
// There is a split in the solution, but it's possible to combine two of the USV4 splits.
// The WETH -> USDC swap cannot get grouped with anything, but the WETH -> DAI and
// DAI -> USDC swaps can be grouped.
//
// ┌──(USV4)──> USDC
// WBTC ──> (USV4)──> WETH ─┤
// └──(USV4)──> DAI ───(USV4)──> USDC
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let weth = weth();
let wbtc = Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599").unwrap();
let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
let swap_wbtc_weth = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: wbtc.clone(),
token_out: weth.clone(),
split: 0f64,
};
let swap_weth_usdc = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.5f64,
};
let swap_weth_dai = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: dai.clone(),
// This represents the remaining 50%, but to avoid any rounding errors we set this to
// 0 to signify "the remainder of the WETH value". It should still be very close to 50%
split: 0f64,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let grouped_swaps = encoder.group_swaps(vec![
swap_wbtc_weth.clone(),
swap_weth_usdc.clone(),
swap_weth_dai.clone(),
swap_dai_usdc.clone(),
]);
assert_eq!(
grouped_swaps,
vec![
SwapGroup {
swaps: vec![swap_wbtc_weth],
input_token: wbtc.clone(),
output_token: weth.clone(),
protocol_system: "uniswap_v4".to_string(),
split: 0f64,
},
SwapGroup {
swaps: vec![swap_weth_usdc],
input_token: weth.clone(),
output_token: usdc.clone(),
protocol_system: "uniswap_v4".to_string(),
split: 0.5f64,
},
SwapGroup {
swaps: vec![swap_weth_dai, swap_dai_usdc],
input_token: weth,
output_token: usdc,
protocol_system: "uniswap_v4".to_string(),
split: 0f64,
}
]
);
}
#[test]
fn test_group_swaps_complex_split_multi_protocol() {
// There is a split in the solution, but it's possible to group the USV4 splits with each
// other and the Balancer V3 swaps with each other.
//
// ┌──(BalancerV3)──> WBTC ──(BalancerV3)──> USDC
// WETH ─┤
// └──(USV4)──> DAI ───(USV4)──> USDC
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let weth = weth();
let wbtc = Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599").unwrap();
let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
let swap_weth_wbtc = Swap {
component: ProtocolComponent {
protocol_system: "balancer_v3".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0.5f64,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
protocol_system: "balancer_v3".to_string(),
..Default::default()
},
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let swap_weth_dai = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: dai.clone(),
// This represents the remaining 50%, but to avoid any rounding errors we set this to
// 0 to signify "the remainder of the WETH value". It should still be very close to 50%
split: 0f64,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
protocol_system: "uniswap_v4".to_string(),
..Default::default()
},
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let grouped_swaps = encoder.group_swaps(vec![
swap_weth_wbtc.clone(),
swap_wbtc_usdc.clone(),
swap_weth_dai.clone(),
swap_dai_usdc.clone(),
]);
assert_eq!(
grouped_swaps,
vec![
SwapGroup {
swaps: vec![swap_weth_wbtc, swap_wbtc_usdc],
input_token: weth.clone(),
output_token: usdc.clone(),
protocol_system: "balancer_v3".to_string(),
split: 0.5f64,
},
SwapGroup {
swaps: vec![swap_weth_dai, swap_dai_usdc],
input_token: weth,
output_token: usdc,
protocol_system: "uniswap_v4".to_string(),
split: 0f64,
}
]
);
}
#[test]
fn test_split_encoding_strategy_usv4() {
// Performs a split swap from WETH to USDC though WBTC using two consecutive USV4 pools