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

chore: address merge conflicts, implement user_data for Bebop

Browse Source
This commit is contained in:
pedrobergamini
2025-06-08 00:36:23 -03:00
parent 68d4d083c3 b4dd4025d4
commit 71a8401670
31 changed files with 1773 additions and 805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,12 +1,12 @@
use std::{str::FromStr, sync::Arc};
use alloy::{
core::sol,
primitives::{aliases::U48, Address, Bytes as AlloyBytes, TxKind, U160, U256},
providers::{Provider, RootProvider},
providers::Provider,
rpc::types::{TransactionInput, TransactionRequest},
transports::BoxTransport,
sol_types::SolValue,
};
use alloy_sol_types::{sol, SolValue};
use chrono::Utc;
use num_bigint::BigUint;
use tokio::{
@@ -19,7 +19,7 @@ use crate::encoding::{
errors::EncodingError,
evm::{
encoding_utils::encode_input,
utils::{biguint_to_u256, bytes_to_address, get_client, get_runtime},
utils::{biguint_to_u256, bytes_to_address, get_client, get_runtime, EVMProvider},
},
models,
};
@@ -29,7 +29,7 @@ use crate::encoding::{
#[derive(Clone)]
pub struct Permit2 {
address: Address,
client: Arc<RootProvider<BoxTransport>>,
client: EVMProvider,
runtime_handle: Handle,
// Store the runtime to prevent it from being dropped before use.
// This is required since tycho-execution does not have a pre-existing runtime.
@@ -132,16 +132,15 @@ impl Permit2 {
let output = block_in_place(|| {
self.runtime_handle
.block_on(async { self.client.call(&tx).await })
.block_on(async { self.client.call(tx).await })
});
match output {
Ok(response) => {
let allowance: Allowance =
Allowance::abi_decode(&response, true).map_err(|_| {
EncodingError::FatalError(
"Failed to decode response for permit2 allowance".to_string(),
)
})?;
let allowance: Allowance = Allowance::abi_decode(&response).map_err(|_| {
EncodingError::FatalError(
"Failed to decode response for permit2 allowance".to_string(),
)
})?;
Ok(allowance)
}
Err(err) => Err(EncodingError::RecoverableError(format!(
@@ -183,8 +182,10 @@ impl Permit2 {
mod tests {
use std::str::FromStr;
use alloy::signers::local::PrivateKeySigner;
use alloy_primitives::{Uint, B256};
use alloy::{
primitives::{Uint, B256},
signers::local::PrivateKeySigner,
};
use num_bigint::BigUint;
use tycho_common::models::Chain as TychoCommonChain;

15
src/encoding/evm/approvals/protocol_approvals_manager.rs
View File

@@ -1,12 +1,11 @@
use std::sync::Arc;
use alloy::{
providers::{Provider, RootProvider},
primitives::{Address, Bytes, TxKind, U256},
providers::Provider,
rpc::types::{TransactionInput, TransactionRequest},
transports::BoxTransport,
sol_types::SolValue,
};
use alloy_primitives::{Address, Bytes, TxKind, U256};
use alloy_sol_types::SolValue;
use tokio::{
runtime::{Handle, Runtime},
task::block_in_place,
@@ -16,13 +15,13 @@ use crate::encoding::{
errors::EncodingError,
evm::{
encoding_utils::encode_input,
utils::{get_client, get_runtime},
utils::{get_client, get_runtime, EVMProvider},
},
};
/// A manager for checking if an approval is needed for interacting with a certain spender.
pub struct ProtocolApprovalsManager {
client: Arc<RootProvider<BoxTransport>>,
client: EVMProvider,
runtime_handle: Handle,
// Store the runtime to prevent it from being dropped before use.
// This is required since tycho-execution does not have a pre-existing runtime.
@@ -56,11 +55,11 @@ impl ProtocolApprovalsManager {
let output = block_in_place(|| {
self.runtime_handle
.block_on(async { self.client.call(&tx).await })
.block_on(async { self.client.call(tx).await })
});
match output {
Ok(response) => {
let allowance: U256 = U256::abi_decode(&response, true).map_err(|_| {
let allowance: U256 = U256::abi_decode(&response).map_err(|_| {
EncodingError::FatalError("Failed to decode response for allowance".to_string())
})?;

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

@@ -31,6 +31,7 @@ pub static IN_TRANSFER_REQUIRED_PROTOCOLS: LazyLock<HashSet<&'static str>> = Laz
set.insert("uniswap_v4");
set.insert("ekubo_v2");
set.insert("vm:maverick_v2");
set.insert("vm:balancer_v3");
set.insert("rfq:bebop");
set
});
@@ -47,6 +48,7 @@ pub static CALLBACK_CONSTRAINED_PROTOCOLS: LazyLock<HashSet<&'static str>> = Laz
set.insert("pancakeswap_v3");
set.insert("uniswap_v4");
set.insert("ekubo_v2");
set.insert("vm:balancer_v3");
set.insert("rfq:bebop");
set
});

3
src/encoding/evm/encoder_builders.rs
View File

@@ -1,7 +1,6 @@
use std::{collections::HashMap, str::FromStr};
use alloy::signers::local::PrivateKeySigner;
use alloy_primitives::B256;
use alloy::{primitives::B256, signers::local::PrivateKeySigner};
use tycho_common::{models::Chain as TychoCommonChain, Bytes};
use crate::encoding::{

5
src/encoding/evm/encoding_utils.rs
View File

@@ -1,11 +1,10 @@
use std::str::FromStr;
use alloy::{
primitives::U256,
primitives::{Address, Keccak256, U256},
signers::{local::PrivateKeySigner, Signature, SignerSync},
sol_types::{eip712_domain, SolStruct, SolValue},
};
use alloy_primitives::{Address, Keccak256};
use alloy_sol_types::{eip712_domain, SolStruct, SolValue};
use num_bigint::BigUint;
use tycho_common::Bytes;

13
src/encoding/evm/group_swaps.rs
View File

@@ -73,7 +73,7 @@ pub fn group_swaps(swaps: Vec<Swap>) -> Vec<SwapGroup> {
mod tests {
use std::str::FromStr;
use alloy_primitives::hex;
use alloy::primitives::hex;
use tycho_common::{models::protocol::ProtocolComponent, Bytes};
use super::*;
@@ -105,6 +105,7 @@ mod tests {
// 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,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -114,6 +115,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let swap_usdc_dai = Swap {
component: ProtocolComponent {
@@ -123,6 +125,7 @@ mod tests {
token_in: usdc.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let grouped_swaps = group_swaps(vec![
swap_weth_wbtc.clone(),
@@ -174,6 +177,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: weth.clone(),
split: 0f64,
user_data: None,
};
let swap_weth_usdc = Swap {
component: ProtocolComponent {
@@ -183,6 +187,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.5f64,
user_data: None,
};
let swap_weth_dai = Swap {
component: ProtocolComponent {
@@ -194,6 +199,7 @@ mod tests {
// 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,
user_data: None,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
@@ -203,6 +209,7 @@ mod tests {
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let grouped_swaps = group_swaps(vec![
swap_wbtc_weth.clone(),
@@ -261,6 +268,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0.5f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -270,6 +278,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let swap_weth_dai = Swap {
component: ProtocolComponent {
@@ -281,6 +290,7 @@ mod tests {
// 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,
user_data: None,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
@@ -290,6 +300,7 @@ mod tests {
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let grouped_swaps = group_swaps(vec![

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

@@ -1,6 +1,6 @@
use std::{collections::HashSet, str::FromStr};
use alloy_primitives::{aliases::U24, U8};
use alloy::primitives::{aliases::U24, U8};
use tycho_common::Bytes;
use crate::encoding::{
@@ -510,8 +510,7 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
mod tests {
use std::{collections::HashMap, str::FromStr};
use alloy::hex::encode;
use alloy_primitives::hex;
use alloy::{hex::encode, primitives::hex};
use num_bigint::{BigInt, BigUint};
use tycho_common::{
models::{protocol::ProtocolComponent, Chain as TychoCommonChain},
@@ -559,6 +558,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder = SingleSwapStrategyEncoder::new(
@@ -619,6 +619,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder = SingleSwapStrategyEncoder::new(
@@ -689,6 +690,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -699,6 +701,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder = SequentialSwapStrategyEncoder::new(
@@ -790,6 +793,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0.6f64, // 60% of input
user_data: None,
};
// USDC -> WETH (Pool 2) - 40% of input (remaining)
@@ -810,7 +814,8 @@ mod tests {
},
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0f64, // Remaining 40%
split: 0f64,
user_data: None, // Remaining 40%
};
// WETH -> USDC (Pool 2)
@@ -832,6 +837,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.0f64,
user_data: None,
};
let swap_encoder_registry = get_swap_encoder_registry();
@@ -939,6 +945,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0.0f64,
user_data: None,
};
let swap_weth_usdc_v3_pool1 = Swap {
@@ -959,6 +966,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.6f64,
user_data: None,
};
let swap_weth_usdc_v3_pool2 = Swap {
@@ -979,6 +987,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.0f64,
user_data: None,
};
let swap_encoder_registry = get_swap_encoder_registry();

21
src/encoding/evm/strategy_encoder/strategy_validators.rs
View File

@@ -214,6 +214,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
}];
let result = validator.validate_swap_path(&swaps, &weth, &dai, &None, &eth, &weth);
assert_eq!(result, Ok(()));
@@ -236,6 +237,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -246,6 +248,7 @@ mod tests {
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
},
];
let result = validator.validate_swap_path(&swaps, &weth, &usdc, &None, &eth, &weth);
@@ -271,6 +274,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5,
user_data: None,
},
// This swap is disconnected from the WETH->DAI path
Swap {
@@ -282,6 +286,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0.0,
user_data: None,
},
];
let result =
@@ -309,6 +314,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -319,6 +325,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
},
];
@@ -344,6 +351,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 1.0,
user_data: None,
}];
let result =
validator.validate_swap_path(&unreachable_swaps, &weth, &usdc, &None, &eth, &weth);
@@ -382,6 +390,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
}];
let result = validator.validate_split_percentages(&swaps);
assert_eq!(result, Ok(()));
@@ -404,6 +413,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -414,6 +424,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.3,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -424,6 +435,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.0, // Remainder (20%)
user_data: None,
},
];
assert!(validator
@@ -447,6 +459,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.7,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -457,6 +470,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.3,
user_data: None,
},
];
assert!(matches!(
@@ -481,6 +495,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.0,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -491,6 +506,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5,
user_data: None,
},
];
assert!(matches!(
@@ -515,6 +531,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.6,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -525,6 +542,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -535,6 +553,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.0,
user_data: None,
},
];
assert!(matches!(
@@ -559,6 +578,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
}];
let result = validator.validate_swap_path(
@@ -588,6 +608,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0f64,
user_data: None,
}];
let result = validator.validate_swap_path(

4
src/encoding/evm/strategy_encoder/transfer_optimizations.rs
View File

@@ -111,7 +111,7 @@ impl TransferOptimization {
#[cfg(test)]
mod tests {
use alloy_primitives::hex;
use alloy::primitives::hex;
use rstest::rstest;
use tycho_common::models::protocol::ProtocolComponent;
@@ -178,6 +178,7 @@ mod tests {
token_in: swap_token_in.clone(),
token_out: dai(),
split: 0f64,
user_data: None,
}];
let swap = SwapGroup {
protocol_system: protocol,
@@ -243,6 +244,7 @@ mod tests {
token_in: usdc(),
token_out: dai(),
split: 0f64,
user_data: None,
}],
})
};

10
src/encoding/evm/swap_encoder/builder.rs
View File

@@ -3,8 +3,9 @@ use std::collections::HashMap;
use crate::encoding::{
errors::EncodingError,
evm::swap_encoder::swap_encoders::{
BalancerV2SwapEncoder, BebopSwapEncoder, CurveSwapEncoder, EkuboSwapEncoder,
MaverickV2SwapEncoder, UniswapV2SwapEncoder, UniswapV3SwapEncoder, UniswapV4SwapEncoder,
BalancerV2SwapEncoder, BalancerV3SwapEncoder, BebopSwapEncoder, CurveSwapEncoder,
EkuboSwapEncoder, MaverickV2SwapEncoder, UniswapV2SwapEncoder, UniswapV3SwapEncoder,
UniswapV4SwapEncoder,
},
models::Chain,
swap_encoder::SwapEncoder,
@@ -81,6 +82,11 @@ impl SwapEncoderBuilder {
self.chain,
self.config,
)?)),
"vm:balancer_v3" => Ok(Box::new(BalancerV3SwapEncoder::new(
self.executor_address,
self.chain,
self.config,
)?)),
"rfq:bebop" => {
Ok(Box::new(BebopSwapEncoder::new(self.executor_address, self.chain, self.config)?))
}

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

@@ -1,3 +1,5 @@
mod builder;
pub mod swap_encoder_registry;
mod swap_encoders;
pub use swap_encoders::BebopOrderType;

393
src/encoding/evm/swap_encoder/swap_encoders.rs
View File

@@ -1,7 +1,9 @@
use std::{collections::HashMap, str::FromStr};
use alloy_primitives::{Address, Bytes as AlloyBytes, U8};
use alloy_sol_types::SolValue;
use alloy::{
primitives::{Address, Bytes as AlloyBytes, U8},
sol_types::SolValue,
};
use serde_json::from_str;
use tycho_common::Bytes;
@@ -230,12 +232,12 @@ impl SwapEncoder for BalancerV2SwapEncoder {
config: Option<HashMap<String, String>>,
) -> Result<Self, EncodingError> {
let config = config.ok_or(EncodingError::FatalError(
"Missing balancer specific addresses in config".to_string(),
"Missing balancer v2 specific addresses in config".to_string(),
))?;
let vault_address = config
.get("vault_address")
.ok_or(EncodingError::FatalError(
"Missing balancer vault address in config".to_string(),
"Missing balancer v2 vault address in config".to_string(),
))?
.to_string();
Ok(Self { executor_address, vault_address })
@@ -569,6 +571,73 @@ impl SwapEncoder for MaverickV2SwapEncoder {
}
}
/// Encodes a swap on a Balancer V3 pool through the given executor address.
///
/// # Fields
/// * `executor_address` - The address of the executor contract that will perform the swap.
#[derive(Clone)]
pub struct BalancerV3SwapEncoder {
executor_address: String,
}
impl SwapEncoder for BalancerV3SwapEncoder {
fn new(
executor_address: String,
_chain: Chain,
_config: Option<HashMap<String, String>>,
) -> Result<Self, EncodingError> {
Ok(Self { executor_address })
}
fn encode_swap(
&self,
swap: Swap,
encoding_context: EncodingContext,
) -> Result<Vec<u8>, EncodingError> {
let pool = Address::from_str(&swap.component.id).map_err(|_| {
EncodingError::FatalError("Invalid pool address for Balancer v3".to_string())
})?;
let args = (
bytes_to_address(&swap.token_in)?,
bytes_to_address(&swap.token_out)?,
pool,
(encoding_context.transfer_type as u8).to_be_bytes(),
bytes_to_address(&encoding_context.receiver)?,
);
Ok(args.abi_encode_packed())
}
fn executor_address(&self) -> &str {
&self.executor_address
}
fn clone_box(&self) -> Box<dyn SwapEncoder> {
Box::new(self.clone())
}
}
/// Bebop order types
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BebopOrderType {
Single = 0,
Multi = 1,
Aggregate = 2,
}
impl TryFrom<u8> for BebopOrderType {
type Error = EncodingError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0 => Ok(BebopOrderType::Single),
1 => Ok(BebopOrderType::Multi),
2 => Ok(BebopOrderType::Aggregate),
_ => Err(EncodingError::InvalidInput(format!("Invalid Bebop order type: {}", value))),
}
}
}
/// Encodes a swap on Bebop (PMM RFQ) through the given executor address.
///
/// Bebop uses a Request-for-Quote model where quotes are obtained off-chain
@@ -643,19 +712,54 @@ impl SwapEncoder for BebopSwapEncoder {
// Validate component ID
Self::validate_component_id(&swap.component.id)?;
// Get quote data and signature from static attributes
let quote_data = get_static_attribute(&swap, "quote_data")?;
let signature = get_static_attribute(&swap, "signature")?;
// Extract data from user_data (required for Bebop)
let user_data = swap.user_data.ok_or_else(|| {
EncodingError::InvalidInput(
"Bebop swaps require user_data with quote and signature".to_string(),
)
})?;
// Get order type (default to Single if not specified)
let order_type = get_static_attribute(&swap, "order_type")
.map(|bytes| bytes[0])
.unwrap_or(0u8); // Default to Single (0)
// Parse user_data format:
// order_type (1 byte) | signature_type (1 byte) | quote_data_length (4 bytes) | quote_data
// | signature_length (4 bytes) | signature
if user_data.len() < 10 {
return Err(EncodingError::InvalidInput(
"User data too short to contain Bebop RFQ data".to_string(),
));
}
// Get signature type (default to 0 = ECDSA if not specified)
let signature_type = get_static_attribute(&swap, "signature_type")
.map(|bytes| bytes[0])
.unwrap_or(0u8); // Default to ECDSA (0)
let order_type = BebopOrderType::try_from(user_data[0])?;
let signature_type = user_data[1];
let quote_data_len =
u32::from_be_bytes([user_data[2], user_data[3], user_data[4], user_data[5]]) as usize;
if user_data.len() < 10 + quote_data_len {
return Err(EncodingError::InvalidInput(
"User data too short to contain quote data".to_string(),
));
}
let quote_data = user_data[6..6 + quote_data_len].to_vec();
let sig_len_start = 6 + quote_data_len;
if user_data.len() < sig_len_start + 4 {
return Err(EncodingError::InvalidInput(
"User data too short to contain signature length".to_string(),
));
}
let signature_len = u32::from_be_bytes([
user_data[sig_len_start],
user_data[sig_len_start + 1],
user_data[sig_len_start + 2],
user_data[sig_len_start + 3],
]) as usize;
if user_data.len() != sig_len_start + 4 + signature_len {
return Err(EncodingError::InvalidInput("User data length mismatch".to_string()));
}
let signature = user_data[sig_len_start + 4..].to_vec();
// Encode packed data for the executor
// Format: token_in | token_out | transfer_type | order_type |
@@ -665,7 +769,7 @@ impl SwapEncoder for BebopSwapEncoder {
token_in,
token_out,
(encoding_context.transfer_type as u8).to_be_bytes(),
order_type.to_be_bytes(),
(order_type as u8).to_be_bytes(),
(quote_data.len() as u32).to_be_bytes(),
&quote_data[..],
signature_type.to_be_bytes(),
@@ -716,6 +820,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
receiver: Bytes::from("0x1D96F2f6BeF1202E4Ce1Ff6Dad0c2CB002861d3e"), // BOB
@@ -775,6 +880,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
receiver: Bytes::from("0x0000000000000000000000000000000000000001"),
@@ -818,7 +924,6 @@ mod tests {
mod balancer_v2 {
use super::*;
use crate::encoding::evm::utils::write_calldata_to_file;
#[test]
fn test_encode_balancer_v2() {
@@ -836,6 +941,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
@@ -908,6 +1014,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver is ALICE to match the solidity tests
@@ -980,6 +1087,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
@@ -1076,6 +1184,7 @@ mod tests {
token_in: usde_address.clone(),
token_out: usdt_address.clone(),
split: 0f64,
user_data: None,
};
let second_swap = Swap {
@@ -1083,6 +1192,7 @@ mod tests {
token_in: usdt_address,
token_out: wbtc_address.clone(),
split: 0f64,
user_data: None,
};
let encoder = UniswapV4SwapEncoder::new(
@@ -1159,6 +1269,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
@@ -1231,6 +1342,7 @@ mod tests {
token_in: group_token_in.clone(),
token_out: intermediary_token.clone(),
split: 0f64,
user_data: None,
};
let second_swap = Swap {
@@ -1246,6 +1358,7 @@ mod tests {
token_in: intermediary_token.clone(),
token_out: group_token_out.clone(),
split: 0f64,
user_data: None,
};
let first_encoded_swap = encoder
@@ -1365,6 +1478,7 @@ mod tests {
token_in: Bytes::from(token_in),
token_out: Bytes::from(token_out),
split: 0f64,
user_data: None,
};
let encoder = CurveSwapEncoder::new(
String::default(),
@@ -1408,6 +1522,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
@@ -1479,6 +1594,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
@@ -1551,6 +1667,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
@@ -1607,59 +1724,121 @@ mod tests {
}
}
#[test]
fn test_encode_maverick_v2() {
// GHO -> (maverick) -> USDC
let maverick_pool = ProtocolComponent {
id: String::from("0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67"),
protocol_system: String::from("vm:maverick_v2"),
..Default::default()
};
let token_in = Bytes::from("0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f");
let token_out = Bytes::from("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
let swap = Swap {
component: maverick_pool,
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
receiver: Bytes::from("0x1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e"),
exact_out: false,
router_address: Some(Bytes::default()),
group_token_in: token_in.clone(),
group_token_out: token_out.clone(),
transfer_type: TransferType::Transfer,
};
let encoder = MaverickV2SwapEncoder::new(
String::from("0x543778987b293C7E8Cf0722BB2e935ba6f4068D4"),
TychoCoreChain::Ethereum.into(),
None,
)
.unwrap();
mod balancer_v3 {
use super::*;
let encoded_swap = encoder
.encode_swap(swap, encoding_context)
#[test]
fn test_encode_balancer_v3() {
let balancer_pool = ProtocolComponent {
id: String::from("0x85b2b559bc2d21104c4defdd6efca8a20343361d"),
protocol_system: String::from("vm:balancer_v3"),
..Default::default()
};
let token_in = Bytes::from("0x7bc3485026ac48b6cf9baf0a377477fff5703af8");
let token_out = Bytes::from("0xc71ea051a5f82c67adcf634c36ffe6334793d24c");
let swap = Swap {
component: balancer_pool,
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
receiver: Bytes::from("0x1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e"),
exact_out: false,
router_address: Some(Bytes::zero(20)),
group_token_in: token_in.clone(),
group_token_out: token_out.clone(),
transfer_type: TransferType::Transfer,
};
let encoder = BalancerV3SwapEncoder::new(
String::from("0x543778987b293C7E8Cf0722BB2e935ba6f4068D4"),
TychoCoreChain::Ethereum.into(),
None,
)
.unwrap();
let hex_swap = encode(&encoded_swap);
let encoded_swap = encoder
.encode_swap(swap, encoding_context)
.unwrap();
let hex_swap = encode(&encoded_swap);
assert_eq!(
hex_swap,
String::from(concat!(
// token in
"40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f",
// pool
"14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67",
// receiver
"1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e",
// transfer true
"01",
))
.to_lowercase()
);
assert_eq!(
hex_swap,
String::from(concat!(
// token in
"7bc3485026ac48b6cf9baf0a377477fff5703af8",
// token out
"c71ea051a5f82c67adcf634c36ffe6334793d24c",
// pool id
"85b2b559bc2d21104c4defdd6efca8a20343361d",
// transfer type None
"01",
// receiver
"1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e",
))
);
write_calldata_to_file("test_encode_balancer_v3", hex_swap.as_str());
}
}
write_calldata_to_file("test_encode_maverick_v2", hex_swap.as_str());
mod maverick_v2 {
use super::*;
#[test]
fn test_encode_maverick_v2() {
// GHO -> (maverick) -> USDC
let maverick_pool = ProtocolComponent {
id: String::from("0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67"),
protocol_system: String::from("vm:maverick_v2"),
..Default::default()
};
let token_in = Bytes::from("0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f");
let token_out = Bytes::from("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
let swap = Swap {
component: maverick_pool,
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoding_context = EncodingContext {
// The receiver was generated with `makeAddr("bob") using forge`
receiver: Bytes::from("0x1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e"),
exact_out: false,
router_address: Some(Bytes::default()),
group_token_in: token_in.clone(),
group_token_out: token_out.clone(),
transfer_type: TransferType::Transfer,
};
let encoder = MaverickV2SwapEncoder::new(
String::from("0x543778987b293C7E8Cf0722BB2e935ba6f4068D4"),
TychoCoreChain::Ethereum.into(),
None,
)
.unwrap();
let encoded_swap = encoder
.encode_swap(swap, encoding_context)
.unwrap();
let hex_swap = encode(&encoded_swap);
assert_eq!(
hex_swap,
String::from(concat!(
// token in
"40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f",
// pool
"14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67",
// receiver
"1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e",
// transfer true
"01",
))
.to_lowercase()
);
write_calldata_to_file("test_encode_maverick_v2", hex_swap.as_str());
}
}
mod bebop {
@@ -1670,17 +1849,24 @@ mod tests {
fn test_encode_bebop_single() {
use alloy::hex;
// Create static attributes for a Bebop RFQ quote
let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
static_attributes
.insert("quote_data".into(), Bytes::from(hex::decode("1234567890abcdef").unwrap()));
static_attributes
.insert("signature".into(), Bytes::from(hex::decode("aabbccdd").unwrap()));
// Create user_data with quote and signature
let order_type = BebopOrderType::Single as u8;
let signature_type = 0u8; // ECDSA
let quote_data = hex::decode("1234567890abcdef").unwrap();
let signature = hex::decode("aabbccdd").unwrap();
let mut user_data = Vec::new();
user_data.push(order_type);
user_data.push(signature_type);
user_data.extend_from_slice(&(quote_data.len() as u32).to_be_bytes());
user_data.extend_from_slice(&quote_data);
user_data.extend_from_slice(&(signature.len() as u32).to_be_bytes());
user_data.extend_from_slice(&signature);
let bebop_component = ProtocolComponent {
id: String::from("bebop-rfq"),
protocol_system: String::from("rfq:bebop"),
static_attributes,
static_attributes: HashMap::new(),
..Default::default()
};
@@ -1691,6 +1877,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: Some(Bytes::from(user_data)),
};
let encoding_context = EncodingContext {
@@ -1726,13 +1913,13 @@ mod tests {
"c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
// transfer type Transfer
"01",
// order type Single (default 0)
// order type Single (0)
"00",
// quote data length (8 bytes = 0x00000008)
"00000008",
// quote data
"1234567890abcdef",
// signature type ECDSA (default 0)
// signature type ECDSA (0)
"00",
// signature length (4 bytes = 0x00000004)
"00000004",
@@ -1750,18 +1937,24 @@ mod tests {
fn test_encode_bebop_multi() {
use alloy::hex;
// Create static attributes for a Bebop Multi RFQ quote
let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
static_attributes
.insert("quote_data".into(), Bytes::from(hex::decode("abcdef1234567890").unwrap()));
static_attributes
.insert("signature".into(), Bytes::from(hex::decode("11223344").unwrap()));
static_attributes.insert("order_type".into(), Bytes::from(vec![1u8])); // Multi order
// Create user_data for a Bebop Multi RFQ quote
let order_type = BebopOrderType::Multi as u8;
let signature_type = 0u8; // ECDSA
let quote_data = hex::decode("abcdef1234567890").unwrap();
let signature = hex::decode("11223344").unwrap();
let mut user_data = Vec::new();
user_data.push(order_type);
user_data.push(signature_type);
user_data.extend_from_slice(&(quote_data.len() as u32).to_be_bytes());
user_data.extend_from_slice(&quote_data);
user_data.extend_from_slice(&(signature.len() as u32).to_be_bytes());
user_data.extend_from_slice(&signature);
let bebop_component = ProtocolComponent {
id: String::from("bebop-rfq"),
protocol_system: String::from("rfq:bebop"),
static_attributes,
static_attributes: HashMap::new(),
..Default::default()
};
@@ -1772,6 +1965,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: Some(Bytes::from(user_data)),
};
let encoding_context = EncodingContext {
@@ -1807,13 +2001,13 @@ mod tests {
"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
// transfer type Transfer
"01",
// order type Multi
// order type Multi (1)
"01",
// quote data length (8 bytes = 0x00000008)
"00000008",
// quote data
"abcdef1234567890",
// signature type ECDSA (default 0)
// signature type ECDSA (0)
"00",
// signature length (4 bytes = 0x00000004)
"00000004",
@@ -1831,21 +2025,25 @@ mod tests {
fn test_encode_bebop_aggregate() {
use alloy::hex;
// Create static attributes for a Bebop Aggregate RFQ quote
let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
static_attributes
.insert("quote_data".into(), Bytes::from(hex::decode("deadbeef").unwrap()));
// Create user_data for a Bebop Aggregate RFQ quote
let order_type = BebopOrderType::Aggregate as u8;
let signature_type = 0u8; // ECDSA
let quote_data = hex::decode("deadbeef").unwrap();
// For aggregate, signature contains multiple signatures encoded
static_attributes.insert(
"signature".into(),
Bytes::from(hex::decode("0000000200000004aabbccdd00000004eeff0011").unwrap()),
);
static_attributes.insert("order_type".into(), Bytes::from(vec![2u8])); // Aggregate order
let signature = hex::decode("0000000200000004aabbccdd00000004eeff0011").unwrap();
let mut user_data = Vec::new();
user_data.push(order_type);
user_data.push(signature_type);
user_data.extend_from_slice(&(quote_data.len() as u32).to_be_bytes());
user_data.extend_from_slice(&quote_data);
user_data.extend_from_slice(&(signature.len() as u32).to_be_bytes());
user_data.extend_from_slice(&signature);
let bebop_component = ProtocolComponent {
id: String::from("bebop-rfq"),
protocol_system: String::from("rfq:bebop"),
static_attributes,
static_attributes: HashMap::new(),
..Default::default()
};
@@ -1856,6 +2054,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: Some(Bytes::from(user_data)),
};
let encoding_context = EncodingContext {
@@ -1891,13 +2090,13 @@ mod tests {
"2260fac5e5542a773aa44fbcfedf7c193bc2c599",
// transfer type TransferFrom
"00",
// order type Aggregate
// order type Aggregate (2)
"02",
// quote data length (4 bytes = 0x00000004)
"00000004",
// quote data
"deadbeef",
// signature type ECDSA (default 0)
// signature type ECDSA (0)
"00",
// signature length (20 bytes for encoded signatures)
"00000014",

295
src/encoding/evm/tycho_encoders.rs
View File

@@ -435,6 +435,7 @@ mod tests {
token_in: usdc().clone(),
token_out: eth().clone(),
split: 0f64,
user_data: None,
}
}
@@ -455,6 +456,7 @@ mod tests {
token_in: eth().clone(),
token_out: pepe().clone(),
split: 0f64,
user_data: None,
}
}
@@ -502,6 +504,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -566,6 +569,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
};
let swap_dai_usdc = Swap {
@@ -577,6 +581,7 @@ mod tests {
token_in: dai(),
token_out: usdc(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -630,6 +635,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -658,6 +664,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -691,6 +698,7 @@ mod tests {
token_in: eth(),
token_out: dai(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -744,6 +752,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -771,6 +780,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -805,6 +815,7 @@ mod tests {
token_in: dai(),
token_out: eth(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -844,6 +855,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0.5f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -854,6 +866,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -864,6 +877,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
},
];
@@ -896,6 +910,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -906,6 +921,7 @@ mod tests {
token_in: weth(),
token_out: usdc(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -916,6 +932,7 @@ mod tests {
token_in: usdc(),
token_out: dai(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -926,6 +943,7 @@ mod tests {
token_in: dai(),
token_out: wbtc(),
split: 0f64,
user_data: None,
},
];
@@ -965,6 +983,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -975,6 +994,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0.5f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -985,6 +1005,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
},
];
@@ -1017,6 +1038,7 @@ mod tests {
token_in: weth(),
token_out: dai(),
split: 0f64,
user_data: None,
},
Swap {
component: ProtocolComponent {
@@ -1027,6 +1049,7 @@ mod tests {
token_in: dai(),
token_out: weth(),
split: 0f64,
user_data: None,
},
];
@@ -1080,6 +1103,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -1139,6 +1163,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let solution = Solution {
@@ -1221,14 +1246,37 @@ mod tests {
mod integration {
use std::{collections::HashMap, str::FromStr};
use alloy::{hex::encode, signers::local::PrivateKeySigner};
use alloy_primitives::{hex, Address, B256, U256};
use alloy_sol_types::SolValue;
use alloy::{
hex::encode,
primitives::{hex, Address, B256, U256},
signers::local::PrivateKeySigner,
sol_types::SolValue,
};
use num_bigint::{BigInt, BigUint};
use tycho_common::{models::protocol::ProtocolComponent, Bytes};
use super::*;
use crate::encoding::evm::utils::{biguint_to_u256, write_calldata_to_file};
use crate::encoding::evm::{
swap_encoder::BebopOrderType,
utils::{biguint_to_u256, write_calldata_to_file},
};
/// Helper function to build Bebop user_data
fn build_bebop_user_data(
order_type: BebopOrderType,
signature_type: u8,
quote_data: &[u8],
signature: &[u8],
) -> Bytes {
let mut user_data = Vec::new();
user_data.push(order_type as u8);
user_data.push(signature_type);
user_data.extend_from_slice(&(quote_data.len() as u32).to_be_bytes());
user_data.extend_from_slice(quote_data);
user_data.extend_from_slice(&(signature.len() as u32).to_be_bytes());
user_data.extend_from_slice(signature);
Bytes::from(user_data)
}
fn get_signer() -> PrivateKeySigner {
// Set up a mock private key for signing (Alice's pk in our contract tests)
@@ -1259,6 +1307,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -1349,6 +1398,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -1433,6 +1483,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::None);
@@ -1514,6 +1565,7 @@ mod tests {
token_in: weth(),
token_out: dai.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -1569,6 +1621,7 @@ mod tests {
token_in: dai.clone(),
token_out: weth(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -1634,6 +1687,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -1644,6 +1698,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -1702,6 +1757,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -1712,6 +1768,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -1814,6 +1871,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0f64,
user_data: None,
};
// WETH -> USDC (Pool 2)
@@ -1835,6 +1893,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -1916,9 +1975,10 @@ mod tests {
mod optimized_transfers {
// In this module we test the ability to chain swaps or not. Different protocols are
// tested. The encoded data is used for solidity tests as well
use super::*;
use std::time::{SystemTime, UNIX_EPOCH};
use super::*;
#[test]
fn test_uniswap_v3_uniswap_v2() {
// Note: This test does not assert anything. It is only used to obtain
@@ -1952,6 +2012,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -1962,6 +2023,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -2033,6 +2095,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -2051,6 +2114,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -2121,6 +2185,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdt = Swap {
@@ -2149,6 +2214,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdt.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -2213,6 +2279,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
@@ -2224,6 +2291,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -2266,18 +2334,21 @@ mod tests {
// Note: This test does not assert anything. It is only used to obtain
// integration test data for our router solidity test.
//
// Performs a sequential swap from WETH to DAI through USDC using USV3 and Bebop RFQ
// Performs a sequential swap from WETH to DAI through USDC using USV3 and Bebop
// RFQ
//
// WETH ───(USV3)──> USDC ───(Bebop RFQ)──> DAI
let weth = weth();
let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
let usdc =
Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let dai =
Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap();
// First swap: WETH -> USDC via UniswapV3
let swap_weth_usdc = Swap {
component: ProtocolComponent {
id: "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640".to_string(), // WETH-USDC USV3 Pool 0.05%
id: "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640".to_string(), /* WETH-USDC USV3 Pool 0.05% */
protocol_system: "uniswap_v3".to_string(),
static_attributes: {
let mut attrs = HashMap::new();
@@ -2292,6 +2363,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
// Second swap: USDC -> DAI via Bebop RFQ
@@ -2299,14 +2371,16 @@ mod tests {
let expiry = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() + 3600; // Current time + 1 hour
.as_secs() +
3600; // Current time + 1 hour
let taker_address = Address::ZERO;
let maker_address =
Address::from_str("0xbbbbbBB520d69a9775E85b458C58c648259FAD5F").unwrap();
let maker_nonce = 1u64;
let taker_token = Address::from_str(&usdc.to_string()).unwrap();
let maker_token = Address::from_str(&dai.to_string()).unwrap();
// For ~2021.75 USDC input (what 1 ETH gives us via USV3), expecting ~2021.75 DAI output
// For ~2021.75 USDC input (what 1 ETH gives us via USV3), expecting ~2021.75
// DAI output
let taker_amount = U256::from_str("2021750881").unwrap(); // 2021.75 USDC (6 decimals)
let maker_amount = U256::from_str("2021750881000000000000").unwrap(); // 2021.75 DAI (18 decimals)
let receiver =
@@ -2329,18 +2403,20 @@ mod tests {
)
.abi_encode();
let quote_data = Bytes::from(quote_data);
let signature = Bytes::from(hex::decode("aabbccdd").unwrap());
let signature = hex::decode("aabbccdd").unwrap();
// Create static attributes for the Bebop component
let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
static_attributes.insert("quote_data".into(), quote_data);
static_attributes.insert("signature".into(), signature);
// Build user_data with the quote and signature
let user_data = build_bebop_user_data(
BebopOrderType::Single,
0, // ECDSA signature type
&quote_data,
&signature,
);
let bebop_component = ProtocolComponent {
id: String::from("bebop-rfq"),
protocol_system: String::from("rfq:bebop"),
static_attributes,
static_attributes: HashMap::new(), // No static attributes needed
..Default::default()
};
@@ -2349,6 +2425,7 @@ mod tests {
token_in: usdc.clone(),
token_out: dai.clone(),
split: 0f64,
user_data: Some(user_data),
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -2358,8 +2435,9 @@ mod tests {
given_token: weth,
given_amount: BigUint::from_str("1_000000000000000000").unwrap(), // 1 WETH
checked_token: dai,
checked_amount: BigUint::from_str("2021750881000000000000").unwrap(), // Expected ~2021.75 DAI
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
checked_amount: BigUint::from_str("2021750881000000000000").unwrap(), /* Expected ~2021.75 DAI */
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.unwrap(),
receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.unwrap(),
swaps: vec![swap_weth_usdc, swap_usdc_dai],
@@ -2416,6 +2494,7 @@ mod tests {
token_in: dai.clone(),
token_out: weth.clone(),
split: 0f64,
user_data: None,
};
let balancer_swap_weth_wbtc = Swap {
@@ -2429,6 +2508,7 @@ mod tests {
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let curve_swap_wbtc_usdt = Swap {
@@ -2457,6 +2537,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdt.clone(),
split: 0f64,
user_data: None,
};
// Ekubo
@@ -2478,6 +2559,7 @@ mod tests {
token_in: usdt.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
// USV4
@@ -2502,6 +2584,7 @@ mod tests {
token_in: usdc.clone(),
token_out: eth.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -2546,6 +2629,85 @@ mod tests {
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_multi_protocol", hex_calldata.as_str());
}
#[test]
fn test_uniswap_v3_balancer_v3() {
// Note: This test does not assert anything. It is only used to obtain
// integration test data for our router solidity test.
//
// WETH ───(USV3)──> WBTC ───(balancer v3)──> QNT
let weth = weth();
let wbtc =
Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599").unwrap();
let qnt =
Bytes::from_str("0x4a220e6096b25eadb88358cb44068a3248254675").unwrap();
let swap_weth_wbtc = Swap {
component: ProtocolComponent {
id: "0xCBCdF9626bC03E24f779434178A73a0B4bad62eD".to_string(),
protocol_system: "uniswap_v3".to_string(),
static_attributes: {
let mut attrs = HashMap::new();
attrs.insert(
"fee".to_string(),
Bytes::from(BigInt::from(3000).to_signed_bytes_be()),
);
attrs
},
..Default::default()
},
token_in: weth.clone(),
token_out: wbtc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_qnt = Swap {
component: ProtocolComponent {
id: "0x571bea0e99e139cd0b6b7d9352ca872dfe0d72dd".to_string(),
protocol_system: "vm:balancer_v3".to_string(),
..Default::default()
},
token_in: wbtc.clone(),
token_out: qnt.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
let solution = Solution {
exact_out: false,
given_token: weth,
given_amount: BigUint::from_str("1_0000000000000000").unwrap(),
checked_token: qnt,
checked_amount: BigUint::from_str("26173932").unwrap(),
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.unwrap(),
receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.unwrap(),
swaps: vec![swap_weth_wbtc, swap_wbtc_qnt],
..Default::default()
};
let encoded_solution = encoder
.encode_solutions(vec![solution.clone()])
.unwrap()[0]
.clone();
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFrom,
eth(),
None,
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_uniswap_v3_balancer_v3", hex_calldata.as_str());
}
}
}
@@ -2578,6 +2740,7 @@ mod tests {
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5f64,
user_data: None,
};
let swap_weth_wbtc = Swap {
component: ProtocolComponent {
@@ -2591,6 +2754,7 @@ mod tests {
// this to 0 to signify "the remainder of the WETH value".
// It should still be very close to 50%
split: 0f64,
user_data: None,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
@@ -2601,6 +2765,7 @@ mod tests {
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
@@ -2611,6 +2776,7 @@ mod tests {
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -2679,6 +2845,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0.6f64, // 60% of input
user_data: None,
};
// USDC -> WETH (Pool 2) - 40% of input (remaining)
@@ -2699,7 +2866,8 @@ mod tests {
},
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0f64, // Remaining 40%
split: 0f64,
user_data: None, // Remaining 40%
};
// WETH -> USDC (Pool 2)
@@ -2721,6 +2889,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -2843,6 +3012,7 @@ mod tests {
token_in: usdc.clone(),
token_out: weth.clone(),
split: 0.0f64,
user_data: None,
};
let swap_weth_usdc_v3_pool1 = Swap {
@@ -2863,6 +3033,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.6f64,
user_data: None,
};
let swap_weth_usdc_v3_pool2 = Swap {
@@ -2883,6 +3054,7 @@ mod tests {
token_in: weth.clone(),
token_out: usdc.clone(),
split: 0.0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -3018,6 +3190,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -3073,6 +3246,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -3141,6 +3315,7 @@ mod tests {
token_in: eth.clone(),
token_out: pepe.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -3211,6 +3386,7 @@ mod tests {
token_in: usdc.clone(),
token_out: eth.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -3289,6 +3465,7 @@ mod tests {
token_in: usdc.clone(),
token_out: eth.clone(),
split: 0f64,
user_data: None,
};
let swap_eth_pepe = Swap {
@@ -3302,6 +3479,7 @@ mod tests {
token_in: eth.clone(),
token_out: pepe.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFromPermit2);
@@ -3410,6 +3588,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -3480,6 +3659,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
@@ -3521,6 +3701,62 @@ mod tests {
);
}
#[test]
fn test_single_encoding_strategy_balancer_v3() {
// steakUSDTlite -> (balancer v3) -> steakUSDR
let balancer_pool = ProtocolComponent {
id: String::from("0xf028ac624074d6793c36dc8a06ecec0f5a39a718"),
protocol_system: String::from("vm:balancer_v3"),
..Default::default()
};
let token_in = Bytes::from("0x097ffedb80d4b2ca6105a07a4d90eb739c45a666");
let token_out = Bytes::from("0x30881baa943777f92dc934d53d3bfdf33382cab3");
let swap = Swap {
component: balancer_pool,
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: None,
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);
let solution = Solution {
exact_out: false,
given_token: token_in,
given_amount: BigUint::from_str("1_000000000000000000").unwrap(),
checked_token: token_out,
checked_amount: BigUint::from_str("1000").unwrap(),
// Alice
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.unwrap(),
swaps: vec![swap],
..Default::default()
};
let encoded_solution = encoder
.encode_solutions(vec![solution.clone()])
.unwrap()[0]
.clone();
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFrom,
eth(),
None,
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file(
"test_single_encoding_strategy_balancer_v3",
hex_calldata.as_str(),
);
}
#[test]
fn test_single_encoding_strategy_bebop() {
// USDC -> (Bebop RFQ) -> WETH
@@ -3564,18 +3800,20 @@ mod tests {
)
.abi_encode();
let quote_data = Bytes::from(quote_data);
let signature = Bytes::from(hex::decode("aabbccdd").unwrap());
let signature = hex::decode("aabbccdd").unwrap();
// Create static attributes for the Bebop component
let mut static_attributes: HashMap<String, Bytes> = HashMap::new();
static_attributes.insert("quote_data".into(), quote_data);
static_attributes.insert("signature".into(), signature);
// Build user_data with the quote and signature
let user_data = build_bebop_user_data(
BebopOrderType::Single,
0, // ECDSA signature type
&quote_data,
&signature,
);
let bebop_component = ProtocolComponent {
id: String::from("bebop-rfq"),
protocol_system: String::from("rfq:bebop"),
static_attributes,
static_attributes: HashMap::new(), // No static attributes needed
..Default::default()
};
@@ -3584,6 +3822,7 @@ mod tests {
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
user_data: Some(user_data),
};
let encoder = get_tycho_router_encoder(UserTransferType::TransferFrom);

24
src/encoding/evm/utils.rs
View File

@@ -6,11 +6,13 @@ use std::{
};
use alloy::{
providers::{ProviderBuilder, RootProvider},
transports::BoxTransport,
primitives::{aliases::U24, Address, U256, U8},
providers::{
fillers::{BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller},
ProviderBuilder, RootProvider,
},
sol_types::SolValue,
};
use alloy_primitives::{aliases::U24, Address, U256, U8};
use alloy_sol_types::SolValue;
use num_bigint::BigUint;
use once_cell::sync::Lazy;
use tokio::runtime::{Handle, Runtime};
@@ -88,13 +90,23 @@ pub fn get_runtime() -> Result<(Handle, Option<Arc<Runtime>>), EncodingError> {
}
}
pub type EVMProvider = Arc<
FillProvider<
JoinFill<
alloy::providers::Identity,
JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>,
>,
RootProvider,
>,
>;
/// Gets the client used for interacting with the EVM-compatible network.
pub async fn get_client() -> Result<Arc<RootProvider<BoxTransport>>, EncodingError> {
pub async fn get_client() -> Result<EVMProvider, EncodingError> {
dotenv::dotenv().ok();
let eth_rpc_url = env::var("RPC_URL")
.map_err(|_| EncodingError::FatalError("Missing RPC_URL in environment".to_string()))?;
let client = ProviderBuilder::new()
.on_builtin(&eth_rpc_url)
.connect(&eth_rpc_url)
.await
.map_err(|_| EncodingError::FatalError("Failed to build provider".to_string()))?;
Ok(Arc::new(client))

11
src/encoding/models.rs
View File

@@ -86,6 +86,8 @@ pub struct Swap {
/// Decimal of the amount to be swapped in this operation (for example, 0.5 means 50%)
#[serde(default)]
pub split: f64,
/// Optional user data to be passed to encoding.
pub user_data: Option<Bytes>,
}
impl Swap {
@@ -94,8 +96,9 @@ impl Swap {
token_in: Bytes,
token_out: Bytes,
split: f64,
user_data: Option<Bytes>,
) -> Self {
Self { component: component.into(), token_in, token_out, split }
Self { component: component.into(), token_in, token_out, split, user_data }
}
}
@@ -295,10 +298,14 @@ mod tests {
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);
let user_data = Some(Bytes::from("0x1234"));
let swap =
Swap::new(component, Bytes::from("0x12"), Bytes::from("34"), 0.5, user_data.clone());
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");
assert_eq!(swap.split, 0.5);
assert_eq!(swap.user_data, user_data);
}
}