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

feat: Don't sign permit2 objects

Browse Source 
We don't want to be responsible for holding private keys -> the user is the one that should do this outside of tycho-execution

Done:
- Remove signature from EncodedSolution
- Introduce UserTransferType and pass that everywhere instead of is_permit2_active and token_in_already_in_router
- Remove signing from permit2. Added it to the encoding_utils.rs only
- Mark encode_full_calldata as deprecated
- Backwards compatibility: still accept a signer for the encode_full_calldata case
- Update all tests

Took 2 hours 10 minutes


Took 13 minutes
This commit is contained in:
Diana Carvalho
2025-05-23 18:22:19 +01:00
parent cdb67f742f
commit c62af2f232
11 changed files with 512 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/bin/tycho-encode.rs
View File

@@ -1,5 +1,10 @@
use std::io::{self, Read};
use std::{
io::{self, Read},
str::FromStr,
};
use alloy::signers::local::PrivateKeySigner;
use alloy_primitives::B256;
use alloy_sol_types::SolValue;
use clap::{Parser, Subcommand};
use tycho_common::{hex_bytes::Bytes, models::Chain};
@@ -8,7 +13,7 @@ use tycho_execution::encoding::{
approvals::permit2::PermitSingle,
encoder_builders::{TychoExecutorEncoderBuilder, TychoRouterEncoderBuilder},
},
models::Solution,
models::{Solution, UserTransferType},
tycho_encoder::TychoEncoder,
};
@@ -56,7 +61,7 @@ pub struct Cli {
#[arg(short, long)]
swapper_pk: Option<String>,
#[arg(short, long)]
token_in_already_in_router: Option<bool>,
user_transfer_type: Option<UserTransferType>,
}
#[derive(Subcommand)]
@@ -91,10 +96,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
builder = builder.router_address(router_address);
}
if let Some(swapper_pk) = cli.swapper_pk {
builder = builder.swapper_pk(swapper_pk);
let pk = B256::from_str(&swapper_pk)?;
builder = builder.signer(PrivateKeySigner::from_bytes(&pk)?);
}
if let Some(token_in_already_in_router) = cli.token_in_already_in_router {
builder = builder.token_in_already_in_router(token_in_already_in_router);
if let Some(user_transfer_type) = cli.user_transfer_type {
builder = builder.user_transfer_type(user_transfer_type);
}
builder.build()?
}
@@ -111,17 +117,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
"n_tokens": format!("{}", &encoded_solutions[0].n_tokens),
"permit": match encoded_solutions[0].permit.as_ref() {
Some(permit) => {
match PermitSingle::try_from(permit.clone()) {
match PermitSingle::try_from(permit) {
Ok(sol_permit) => format!("0x{}", hex::encode(sol_permit.abi_encode())),
Err(_) => String::new(), // or log or panic or whatever fallback
Err(_) => String::new(),
}
}
None => String::new(),
},
"signature": encoded_solutions[0].signature
.as_ref()
.map(|signature| format!("0x{}", hex::encode(signature)))
.unwrap_or_else(String::new),
});
// Output the encoded result as JSON to stdout
println!(

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

@@ -4,11 +4,9 @@ use alloy::{
primitives::{aliases::U48, Address, Bytes as AlloyBytes, TxKind, U160, U256},
providers::{Provider, RootProvider},
rpc::types::{TransactionInput, TransactionRequest},
signers::{local::PrivateKeySigner, SignerSync},
transports::BoxTransport,
};
use alloy_primitives::{PrimitiveSignature as Signature, B256};
use alloy_sol_types::{eip712_domain, sol, SolStruct, SolValue};
use alloy_sol_types::{sol, SolValue};
use chrono::Utc;
use num_bigint::BigUint;
use tokio::{
@@ -24,7 +22,6 @@ use crate::encoding::{
utils::{biguint_to_u256, bytes_to_address, get_client, get_runtime},
},
models,
models::Chain,
};
/// Struct for managing Permit2 operations, including encoding approvals and fetching allowance
@@ -33,8 +30,6 @@ use crate::encoding::{
pub struct Permit2 {
address: Address,
client: Arc<RootProvider<BoxTransport>>,
signer: PrivateKeySigner,
chain_id: u64,
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.
@@ -69,10 +64,10 @@ sol! {
}
}
impl TryFrom<PermitSingle> for models::PermitSingle {
impl TryFrom<&PermitSingle> for models::PermitSingle {
type Error = EncodingError;
fn try_from(sol: PermitSingle) -> Result<Self, EncodingError> {
fn try_from(sol: &PermitSingle) -> Result<Self, EncodingError> {
Ok(models::PermitSingle {
details: models::PermitDetails {
token: Bytes::from(sol.details.token.to_vec()),
@@ -90,10 +85,10 @@ impl TryFrom<PermitSingle> for models::PermitSingle {
}
}
impl TryFrom<models::PermitSingle> for PermitSingle {
impl TryFrom<&models::PermitSingle> for PermitSingle {
type Error = EncodingError;
fn try_from(p: models::PermitSingle) -> Result<Self, EncodingError> {
fn try_from(p: &models::PermitSingle) -> Result<Self, EncodingError> {
Ok(PermitSingle {
details: PermitDetails {
token: bytes_to_address(&p.details.token)?,
@@ -108,22 +103,14 @@ impl TryFrom<models::PermitSingle> for PermitSingle {
}
impl Permit2 {
pub fn new(swapper_pk: String, chain: Chain) -> Result<Self, EncodingError> {
pub fn new() -> Result<Self, EncodingError> {
let (handle, runtime) = get_runtime()?;
let client = block_in_place(|| handle.block_on(get_client()))?;
let pk = B256::from_str(&swapper_pk).map_err(|_| {
EncodingError::FatalError("Failed to convert swapper private key to B256".to_string())
})?;
let signer = PrivateKeySigner::from_bytes(&pk).map_err(|_| {
EncodingError::FatalError("Failed to create signer from private key".to_string())
})?;
Ok(Self {
address: Address::from_str("0x000000000022D473030F116dDEE9F6B43aC78BA3")
.map_err(|_| EncodingError::FatalError("Permit2 address not valid".to_string()))?,
client,
runtime_handle: handle,
signer,
chain_id: chain.id,
runtime,
})
}
@@ -169,7 +156,7 @@ impl Permit2 {
owner: &Bytes,
token: &Bytes,
amount: &BigUint,
) -> Result<(models::PermitSingle, Signature), EncodingError> {
) -> Result<models::PermitSingle, EncodingError> {
let current_time = Utc::now()
.naive_utc()
.and_utc()
@@ -188,21 +175,7 @@ impl Permit2 {
sigDeadline: sig_deadline,
};
let domain = eip712_domain! {
name: "Permit2",
chain_id: self.chain_id,
verifying_contract: self.address,
};
let hash = permit_single.eip712_signing_hash(&domain);
let signature = self
.signer
.sign_hash_sync(&hash)
.map_err(|e| {
EncodingError::FatalError(format!(
"Failed to sign permit2 approval with error: {e}"
))
})?;
Ok((models::PermitSingle::try_from(permit_single)?, signature))
Ok(models::PermitSingle::try_from(&permit_single)?)
}
}
@@ -210,11 +183,13 @@ impl Permit2 {
mod tests {
use std::str::FromStr;
use alloy_primitives::Uint;
use alloy::signers::local::PrivateKeySigner;
use alloy_primitives::{Uint, B256};
use num_bigint::BigUint;
use tycho_common::models::Chain as TychoCommonChain;
use super::*;
use crate::encoding::{evm::encoding_utils::sign_permit, models::Chain};
// These two implementations are to avoid comparing the expiration and sig_deadline fields
// because they are timestamps
@@ -253,9 +228,7 @@ mod tests {
#[test]
fn test_get_existing_allowance() {
let swapper_pk =
"4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
let manager = Permit2::new(swapper_pk, eth_chain()).unwrap();
let manager = Permit2::new().unwrap();
let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
@@ -272,17 +245,14 @@ mod tests {
#[test]
fn test_get_permit() {
// Set up a mock private key for signing
let private_key =
"4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
let permit2 = Permit2::new(private_key, eth_chain()).expect("Failed to create Permit2");
let permit2 = Permit2::new().expect("Failed to create Permit2");
let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
let spender = Bytes::from_str("0xba12222222228d8ba445958a75a0704d566bf2c8").unwrap();
let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let amount = BigUint::from(1000u64);
let (permit, _) = permit2
let permit = permit2
.get_permit(&spender, &owner, &token, &amount)
.unwrap();
@@ -315,8 +285,19 @@ mod tests {
let anvil_private_key =
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".to_string();
let permit2 =
Permit2::new(anvil_private_key, eth_chain()).expect("Failed to create Permit2");
let pk = B256::from_str(&anvil_private_key)
.map_err(|_| {
EncodingError::FatalError(
"Failed to convert swapper private key to B256".to_string(),
)
})
.unwrap();
let signer = PrivateKeySigner::from_bytes(&pk)
.map_err(|_| {
EncodingError::FatalError("Failed to create signer from private key".to_string())
})
.unwrap();
let permit2 = Permit2::new().expect("Failed to create Permit2");
let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let amount = BigUint::from(1000u64);
@@ -346,11 +327,13 @@ mod tests {
let spender = Bytes::from_str("0xba12222222228d8ba445958a75a0704d566bf2c8").unwrap();
let (permit, signature) = permit2
let permit = permit2
.get_permit(&spender, &anvil_account, &token, &amount)
.unwrap();
let sol_permit: PermitSingle =
PermitSingle::try_from(permit).expect("Failed to convert to PermitSingle");
PermitSingle::try_from(&permit).expect("Failed to convert to PermitSingle");
let signature = sign_permit(eth_chain().id, &permit, signer).unwrap();
let encoded =
(bytes_to_address(&anvil_account).unwrap(), sol_permit, signature.as_bytes().to_vec())
.abi_encode();

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

@@ -1,5 +1,6 @@
use std::collections::HashMap;
use alloy::signers::local::PrivateKeySigner;
use tycho_common::{models::Chain as TychoCommonChain, Bytes};
use crate::encoding::{
@@ -9,7 +10,7 @@ use crate::encoding::{
swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
tycho_encoders::{TychoExecutorEncoder, TychoRouterEncoder},
},
models::Chain,
models::{Chain, UserTransferType},
tycho_encoder::TychoEncoder,
};
@@ -17,11 +18,11 @@ use crate::encoding::{
///
/// This struct allows setting a chain and strategy encoder before building the final encoder.
pub struct TychoRouterEncoderBuilder {
swapper_pk: Option<String>,
chain: Option<Chain>,
user_transfer_type: Option<UserTransferType>,
executors_file_path: Option<String>,
router_address: Option<Bytes>,
token_in_already_in_router: Option<bool>,
signer: Option<PrivateKeySigner>,
}
impl Default for TychoRouterEncoderBuilder {
@@ -33,11 +34,11 @@ impl Default for TychoRouterEncoderBuilder {
impl TychoRouterEncoderBuilder {
pub fn new() -> Self {
TychoRouterEncoderBuilder {
swapper_pk: None,
chain: None,
executors_file_path: None,
router_address: None,
token_in_already_in_router: None,
signer: None,
user_transfer_type: None,
}
}
pub fn chain(mut self, chain: TychoCommonChain) -> Self {
@@ -45,6 +46,11 @@ impl TychoRouterEncoderBuilder {
self
}
pub fn user_transfer_type(mut self, user_transfer_type: UserTransferType) -> Self {
self.user_transfer_type = Some(user_transfer_type);
self
}
/// Sets the `executors_file_path` manually.
/// If it's not set, the default path will be used (config/executor_addresses.json)
pub fn executors_file_path(mut self, executors_file_path: String) -> Self {
@@ -59,25 +65,15 @@ impl TychoRouterEncoderBuilder {
self
}
pub fn swapper_pk(mut self, swapper_pk: String) -> Self {
self.swapper_pk = Some(swapper_pk);
self
}
// Sets the `token_in_already_in_router` flag.
// If set to true, the encoder will assume that the token in is already in the router.
// WARNING: this is an advanced feature and should be used with caution. Make sure you have
// checks to make sure that your tokens won't be lost. The Router is not considered safe to hold
// tokens, so if this is not done within the same transaction you will lose your tokens.
pub fn token_in_already_in_router(mut self, token_in_already_in_router: bool) -> Self {
self.token_in_already_in_router = Some(token_in_already_in_router);
pub fn signer(mut self, signer: PrivateKeySigner) -> Self {
self.signer = Some(signer);
self
}
/// Builds the `TychoRouterEncoder` instance using the configured chain.
/// Returns an error if either the chain has not been set.
pub fn build(self) -> Result<Box<dyn TychoEncoder>, EncodingError> {
if let Some(chain) = self.chain {
if let (Some(chain), Some(user_transfer_type)) = (self.chain, self.user_transfer_type) {
let tycho_router_address;
if let Some(address) = self.router_address {
tycho_router_address = address;
@@ -98,14 +94,14 @@ impl TychoRouterEncoderBuilder {
Ok(Box::new(TychoRouterEncoder::new(
chain,
swap_encoder_registry,
self.swapper_pk,
tycho_router_address,
self.token_in_already_in_router
.unwrap_or(false),
user_transfer_type,
self.signer,
)?))
} else {
Err(EncodingError::FatalError(
"Please set the chain and router address before building the encoder".to_string(),
"Please set the chain and user transfer type before building the encoder"
.to_string(),
))
}
}

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

@@ -1,5 +1,11 @@
use alloy_primitives::{Keccak256, U256};
use alloy_sol_types::SolValue;
use std::str::FromStr;
use alloy::{
primitives::U256,
signers::{local::PrivateKeySigner, Signature, SignerSync},
};
use alloy_primitives::{Address, Keccak256};
use alloy_sol_types::{eip712_domain, SolStruct, SolValue};
use num_bigint::BigUint;
use tycho_common::Bytes;
@@ -9,7 +15,8 @@ use crate::encoding::{
approvals::permit2::PermitSingle,
utils::{biguint_to_u256, bytes_to_address},
},
models::{EncodedSolution, NativeAction, Solution, Transaction},
models,
models::{EncodedSolution, NativeAction, Solution, Transaction, UserTransferType},
};
/// Encodes the input data for a function call to the given function selector.
@@ -56,6 +63,7 @@ pub fn encode_input(selector: &str, mut encoded_args: Vec<u8>) -> Vec<u8> {
/// their own encoding logic** to ensure:
/// - Full control of parameters passed to the router.
/// - Proper validation and setting of critical inputs such as `minAmountOut`.
/// - Signing of permit2 objects.
///
/// While Tycho is responsible for encoding the swap paths themselves, the input arguments
/// to the router's methods act as **guardrails** for on-chain execution safety.
@@ -87,10 +95,12 @@ pub fn encode_input(selector: &str, mut encoded_args: Vec<u8>) -> Vec<u8> {
/// - Returns `EncodingError::FatalError` if the selector is unsupported or required fields (e.g.,
/// permit or signature) are missing.
pub fn encode_tycho_router_call(
chain_id: u64,
encoded_solution: EncodedSolution,
solution: &Solution,
token_in_already_in_router: bool,
user_transfer_type: UserTransferType,
native_address: Bytes,
signer: Option<PrivateKeySigner>,
) -> Result<Transaction, EncodingError> {
let (mut unwrap, mut wrap) = (false, false);
if let Some(action) = solution.native_action.clone() {
@@ -106,23 +116,23 @@ pub fn encode_tycho_router_call(
let checked_token = bytes_to_address(&solution.checked_token)?;
let receiver = bytes_to_address(&solution.receiver)?;
let n_tokens = U256::from(encoded_solution.n_tokens);
let permit = if let Some(p) = encoded_solution.permit {
Some(
PermitSingle::try_from(p)
let (permit, signature) = if let Some(p) = encoded_solution.permit {
let permit = Some(
PermitSingle::try_from(&p)
.map_err(|_| EncodingError::InvalidInput("Invalid permit".to_string()))?,
)
);
let signer = signer
.ok_or(EncodingError::FatalError("Signer must be set to use permit2".to_string()))?;
let signature = sign_permit(chain_id, &p, signer)?;
(permit, signature.as_bytes().to_vec())
} else {
None
(None, vec![])
};
let method_calldata = if encoded_solution
.selector
.contains("singleSwapPermit2")
{
let sig = encoded_solution
.signature
.ok_or(EncodingError::FatalError("Signature must be set to use permit2".to_string()))?;
println!("sig {:}", hex::encode(&sig));
(
given_amount,
given_token,
@@ -134,7 +144,7 @@ pub fn encode_tycho_router_call(
permit.ok_or(EncodingError::FatalError(
"permit2 object must be set to use permit2".to_string(),
))?,
sig,
signature,
encoded_solution.swaps,
)
.abi_encode()
@@ -150,7 +160,7 @@ pub fn encode_tycho_router_call(
wrap,
unwrap,
receiver,
!token_in_already_in_router,
user_transfer_type == UserTransferType::TransferFrom,
encoded_solution.swaps,
)
.abi_encode()
@@ -169,11 +179,7 @@ pub fn encode_tycho_router_call(
permit.ok_or(EncodingError::FatalError(
"permit2 object must be set to use permit2".to_string(),
))?,
encoded_solution
.signature
.ok_or(EncodingError::FatalError(
"Signature must be set to use permit2".to_string(),
))?,
signature,
encoded_solution.swaps,
)
.abi_encode()
@@ -189,7 +195,7 @@ pub fn encode_tycho_router_call(
wrap,
unwrap,
receiver,
!token_in_already_in_router,
user_transfer_type == UserTransferType::TransferFrom,
encoded_solution.swaps,
)
.abi_encode()
@@ -209,11 +215,7 @@ pub fn encode_tycho_router_call(
permit.ok_or(EncodingError::FatalError(
"permit2 object must be set to use permit2".to_string(),
))?,
encoded_solution
.signature
.ok_or(EncodingError::FatalError(
"Signature must be set to use permit2".to_string(),
))?,
signature,
encoded_solution.swaps,
)
.abi_encode()
@@ -230,7 +232,7 @@ pub fn encode_tycho_router_call(
unwrap,
n_tokens,
receiver,
!token_in_already_in_router,
user_transfer_type == UserTransferType::TransferFrom,
encoded_solution.swaps,
)
.abi_encode()
@@ -246,3 +248,33 @@ pub fn encode_tycho_router_call(
};
Ok(Transaction { to: encoded_solution.interacting_with, value, data: contract_interaction })
}
/// Signs a Permit2 `PermitSingle` struct using the EIP-712 signing scheme.
///
/// This function constructs an EIP-712 domain specific to the Permit2 contract and computes the
/// hash of the provided `PermitSingle`. It then uses the given `PrivateKeySigner` to produce
/// a cryptographic signature of the permit.
///
/// # Warning
/// This is only an **example implementation** provided for reference purposes.
/// **Do not rely on this in production.** You should implement your own version.
pub fn sign_permit(
chain_id: u64,
permit_single: &models::PermitSingle,
signer: PrivateKeySigner,
) -> Result<Signature, EncodingError> {
let permit2_address = Address::from_str("0x000000000022D473030F116dDEE9F6B43aC78BA3")
.map_err(|_| EncodingError::FatalError("Permit2 address not valid".to_string()))?;
let domain = eip712_domain! {
name: "Permit2",
chain_id: chain_id,
verifying_contract: permit2_address,
};
let permit_single: PermitSingle = PermitSingle::try_from(permit_single)?;
let hash = permit_single.eip712_signing_hash(&domain);
signer
.sign_hash_sync(&hash)
.map_err(|e| {
EncodingError::FatalError(format!("Failed to sign permit2 approval with error: {e}"))
})
}

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

@@ -14,7 +14,7 @@ use crate::encoding::{
swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
utils::{get_token_position, percentage_to_uint24, ple_encode},
},
models::{Chain, EncodedSolution, EncodingContext, NativeAction, Solution},
models::{Chain, EncodedSolution, EncodingContext, NativeAction, Solution, UserTransferType},
strategy_encoder::StrategyEncoder,
swap_encoder::SwapEncoder,
};
@@ -38,11 +38,10 @@ impl SingleSwapStrategyEncoder {
pub fn new(
chain: Chain,
swap_encoder_registry: SwapEncoderRegistry,
permit_2_active: bool,
user_transfer_type: UserTransferType,
router_address: Bytes,
token_in_already_in_router: bool,
) -> Result<Self, EncodingError> {
let selector = if permit_2_active {
let selector = if user_transfer_type == UserTransferType::TransferFromPermit2 {
"singleSwapPermit2(uint256,address,address,uint256,bool,bool,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)"
} else {
"singleSwap(uint256,address,address,uint256,bool,bool,address,bool,bytes)"
@@ -55,7 +54,7 @@ impl SingleSwapStrategyEncoder {
transfer_optimization: TransferOptimization::new(
chain.native_token()?,
chain.wrapped_token()?,
token_in_already_in_router,
user_transfer_type,
router_address,
),
})
@@ -138,7 +137,6 @@ impl StrategyEncoder for SingleSwapStrategyEncoder {
interacting_with: self.router_address.clone(),
swaps: swap_data,
permit: None,
signature: None,
n_tokens: 0,
})
}
@@ -179,11 +177,10 @@ impl SequentialSwapStrategyEncoder {
pub fn new(
chain: Chain,
swap_encoder_registry: SwapEncoderRegistry,
permit_2_active: bool,
user_transfer_type: UserTransferType,
router_address: Bytes,
token_in_already_in_router: bool,
) -> Result<Self, EncodingError> {
let selector = if permit_2_active {
let selector = if user_transfer_type == UserTransferType::TransferFromPermit2 {
"sequentialSwapPermit2(uint256,address,address,uint256,bool,bool,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)"
} else {
"sequentialSwap(uint256,address,address,uint256,bool,bool,address,bool,bytes)"
@@ -199,7 +196,7 @@ impl SequentialSwapStrategyEncoder {
transfer_optimization: TransferOptimization::new(
chain.native_token()?,
chain.wrapped_token()?,
token_in_already_in_router,
user_transfer_type,
router_address,
),
})
@@ -294,7 +291,6 @@ impl StrategyEncoder for SequentialSwapStrategyEncoder {
selector: self.selector.clone(),
swaps: encoded_swaps,
permit: None,
signature: None,
n_tokens: 0,
})
}
@@ -335,11 +331,10 @@ impl SplitSwapStrategyEncoder {
pub fn new(
chain: Chain,
swap_encoder_registry: SwapEncoderRegistry,
permit_2_active: bool,
user_transfer_type: UserTransferType,
router_address: Bytes,
token_in_already_in_router: bool,
) -> Result<Self, EncodingError> {
let selector = if permit_2_active{
let selector = if user_transfer_type == UserTransferType::TransferFromPermit2 {
"splitSwapPermit2(uint256,address,address,uint256,bool,bool,uint256,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)"
} else {
"splitSwap(uint256,address,address,uint256,bool,bool,uint256,address,bool,bytes)"
@@ -354,7 +349,7 @@ impl SplitSwapStrategyEncoder {
transfer_optimization: TransferOptimization::new(
chain.native_token()?,
chain.wrapped_token()?,
token_in_already_in_router,
user_transfer_type,
router_address,
),
})
@@ -497,7 +492,6 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
selector: self.selector.clone(),
swaps: encoded_swaps,
permit: None,
signature: None,
n_tokens: tokens_len,
})
}
@@ -516,8 +510,8 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
mod tests {
use std::{collections::HashMap, str::FromStr};
use alloy::hex::encode;
use alloy_primitives::{hex, Address, PrimitiveSignature as Signature, U256};
use alloy::{hex::encode, signers::local::PrivateKeySigner};
use alloy_primitives::{hex, Address, B256, U256};
use num_bigint::{BigInt, BigUint};
use tycho_common::{
models::{protocol::ProtocolComponent, Chain as TychoCommonChain},
@@ -555,24 +549,26 @@ mod tests {
Bytes::from_str("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395").unwrap()
}
fn get_permit(
chain: Chain,
router_address: Bytes,
solution: &Solution,
) -> (PermitSingle, Signature) {
// Set up a mock private key for signing (Alice's pk in our contract tests)
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let permit2 = Permit2::new(private_key, chain.clone()).unwrap();
permit2
fn get_permit(router_address: Bytes, solution: &Solution) -> PermitSingle {
let permit2 = Permit2::new().unwrap();
let permit_single = permit2
.get_permit(
&router_address,
&solution.sender,
&solution.given_token,
&solution.given_amount,
)
.unwrap()
.unwrap();
permit_single
}
fn get_signer() -> PrivateKeySigner {
// Set up a mock private key for signing (Alice's pk in our contract tests)
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let pk = B256::from_str(&private_key).unwrap();
PrivateKeySigner::from_bytes(&pk).unwrap()
}
mod single {
@@ -602,9 +598,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -622,13 +617,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let expected_min_amount_encoded =
hex::encode(U256::abi_encode(&biguint_to_u256(&checked_amount)));
let expected_input = [
@@ -690,9 +691,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -710,9 +710,16 @@ mod tests {
let encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFrom,
eth(),
None,
)
.unwrap()
.data;
let expected_min_amount_encoded = hex::encode(U256::abi_encode(&expected_min_amount));
let expected_input = [
"5c4b639c", // Function selector
@@ -772,9 +779,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::None,
router_address(),
true,
)
.unwrap();
let solution = Solution {
@@ -792,9 +798,16 @@ mod tests {
let encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, true, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::None,
eth(),
None,
)
.unwrap()
.data;
let expected_min_amount_encoded = hex::encode(U256::abi_encode(&expected_min_amount));
let expected_input = [
"5c4b639c", // Function selector
@@ -851,9 +864,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -872,13 +884,19 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_single_swap_strategy_encoder_wrap", hex_calldata.as_str());
}
@@ -905,9 +923,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
let solution = Solution {
@@ -926,13 +943,19 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file(
@@ -982,9 +1005,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1002,13 +1024,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_sequential_swap_strategy_encoder", hex_calldata.as_str());
@@ -1048,9 +1076,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1069,9 +1096,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFrom,
eth(),
None,
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
@@ -1170,9 +1204,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
@@ -1192,13 +1225,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = hex::encode(&calldata);
let expected_input = [
"51bcc7b6", // selector
@@ -1292,9 +1331,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1314,9 +1352,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_uniswap_v2", hex_calldata.as_str());
@@ -1377,9 +1422,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1399,9 +1443,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_uniswap_v3", hex_calldata.as_str());
@@ -1471,9 +1522,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1493,9 +1543,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_curve", hex_calldata.as_str());
@@ -1541,9 +1598,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1563,9 +1619,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_balancer_v2_uniswap_v2", hex_calldata.as_str());
@@ -1687,9 +1750,8 @@ mod tests {
let encoder = SequentialSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
router_address(),
false,
)
.unwrap();
let solution = Solution {
@@ -1714,13 +1776,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth)
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth,
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_multi_protocol", hex_calldata.as_str());
@@ -1795,9 +1863,8 @@ mod tests {
let encoder = SplitSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
let solution = Solution {
@@ -1815,13 +1882,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file("test_split_swap_strategy_encoder", hex_calldata.as_str());
@@ -1907,9 +1980,8 @@ mod tests {
let encoder = SplitSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
@@ -1930,13 +2002,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = hex::encode(&calldata);
let expected_input = [
@@ -2071,9 +2149,8 @@ mod tests {
let encoder = SplitSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
@@ -2094,13 +2171,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth(),
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = hex::encode(&calldata);
let expected_input = [
@@ -2202,9 +2285,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
Bytes::from_str("0xA4AD4f68d0b91CFD19687c881e50f3A00242828c").unwrap(),
false,
)
.unwrap();
@@ -2225,9 +2307,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_ekubo", hex_calldata.as_str());
}
@@ -2253,9 +2342,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
Bytes::from_str("0xA4AD4f68d0b91CFD19687c881e50f3A00242828c").unwrap(),
false,
)
.unwrap();
@@ -2276,9 +2364,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_maverick", hex_calldata.as_str());
}
@@ -2316,9 +2411,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
@@ -2337,13 +2431,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth)
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth,
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file(
@@ -2389,9 +2489,8 @@ mod tests {
let encoder = SplitSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
@@ -2410,13 +2509,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth)
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth,
Some(get_signer()),
)
.unwrap()
.data;
let hex_calldata = encode(&calldata);
write_calldata_to_file(
@@ -2481,9 +2586,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
true,
UserTransferType::TransferFromPermit2,
Bytes::from("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395"),
false,
)
.unwrap();
let solution = Solution {
@@ -2501,13 +2605,19 @@ mod tests {
let mut encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let (permit, signature) = get_permit(eth_chain(), router_address(), &solution);
let permit = get_permit(router_address(), &solution);
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth)
.unwrap()
.data;
let calldata = encode_tycho_router_call(
eth_chain().id,
encoded_solution,
&solution,
UserTransferType::TransferFromPermit2,
eth,
Some(get_signer()),
)
.unwrap()
.data;
let expected_input = [
"30ace1b1", // Function selector (single swap)
@@ -2591,9 +2701,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
@@ -2614,9 +2723,16 @@ mod tests {
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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_curve", hex_calldata.as_str());
@@ -2657,9 +2773,8 @@ mod tests {
let encoder = SingleSwapStrategyEncoder::new(
eth_chain(),
swap_encoder_registry,
false,
UserTransferType::TransferFrom,
router_address(),
false,
)
.unwrap();
@@ -2679,9 +2794,16 @@ mod tests {
let encoded_solution = encoder
.encode_strategy(solution.clone())
.unwrap();
let calldata = encode_tycho_router_call(encoded_solution, &solution, false, eth())
.unwrap()
.data;
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(

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

@@ -8,7 +8,7 @@ use crate::encoding::{
constants::{CALLBACK_CONSTRAINED_PROTOCOLS, IN_TRANSFER_REQUIRED_PROTOCOLS},
group_swaps::SwapGroup,
},
models::TransferType,
models::{TransferType, UserTransferType},
};
/// A struct that defines how the tokens will be transferred into the given pool given the solution.
@@ -16,7 +16,7 @@ use crate::encoding::{
pub struct TransferOptimization {
native_token: Bytes,
wrapped_token: Bytes,
token_in_already_in_router: bool,
user_transfer_type: UserTransferType,
router_address: Bytes,
}
@@ -24,15 +24,10 @@ impl TransferOptimization {
pub fn new(
native_token: Bytes,
wrapped_token: Bytes,
token_in_already_in_router: bool,
user_transfer_type: UserTransferType,
router_address: Bytes,
) -> Self {
TransferOptimization {
native_token,
wrapped_token,
token_in_already_in_router,
router_address,
}
TransferOptimization { native_token, wrapped_token, user_transfer_type, router_address }
}
/// Returns the transfer type that should be used for the current transfer.
@@ -55,7 +50,7 @@ impl TransferOptimization {
TransferType::Transfer
} else if is_first_swap {
if in_transfer_required {
if self.token_in_already_in_router {
if self.user_transfer_type == UserTransferType::None {
// Transfer from router to pool.
TransferType::Transfer
} else {
@@ -64,7 +59,7 @@ impl TransferOptimization {
}
// in transfer is not necessary for these protocols. Only make a transfer from the
// swapper to the router if the tokens are not already in the router
} else if !self.token_in_already_in_router {
} else if self.user_transfer_type != UserTransferType::None {
// Transfer from swapper to router using.
TransferType::TransferFrom
} else {
@@ -146,30 +141,30 @@ mod tests {
#[rstest]
// First swap tests
// WETH -(univ2)-> DAI we expect a transfer from the user to the protocol
#[case(weth(), weth(), "uniswap_v2".to_string(), false, false,false, TransferType::TransferFrom)]
#[case(weth(), weth(), "uniswap_v2".to_string(), false, UserTransferType::TransferFrom,false, TransferType::TransferFrom)]
// Native token swap. No transfer is needed
#[case(eth(), eth(), "uniswap_v2".to_string(),false, false,false, TransferType::None)]
#[case(eth(), eth(), "uniswap_v2".to_string(),false, UserTransferType::TransferFrom,false, TransferType::None)]
// ETH -(wrap)-> WETH -(univ2)-> DAI. Only a transfer from the router into the protocol is
// needed
#[case(eth(), weth(), "uniswap_v2".to_string(),true, false,false,TransferType::Transfer)]
#[case(eth(), weth(), "uniswap_v2".to_string(),true, UserTransferType::TransferFrom,false,TransferType::Transfer)]
// USDC -(univ2)-> DAI and the tokens are already in the router. Only a transfer from the router
// to the protocol is needed
#[case(usdc(), usdc(), "uniswap_v2".to_string(),false, true,false, TransferType::Transfer)]
#[case(usdc(), usdc(), "uniswap_v2".to_string(),false, UserTransferType::None,false, TransferType::Transfer)]
// USDC -(curve)-> DAI and the tokens are already in the router. No transfer is needed
#[case(usdc(), usdc(), "vm:curve".to_string(),false, true, false,TransferType::None)]
#[case(usdc(), usdc(), "vm:curve".to_string(),false, UserTransferType::None, false,TransferType::None)]
// other swaps tests
// tokens need to be transferred into the pool
#[case(weth(), usdc(), "uniswap_v2".to_string(), false, false,false, TransferType::Transfer)]
#[case(weth(), usdc(), "uniswap_v2".to_string(), false, UserTransferType::TransferFrom,false, TransferType::Transfer)]
// tokens are already in the pool (optimization)
#[case(weth(), usdc(), "uniswap_v2".to_string(), false, false, true, TransferType::None)]
#[case(weth(), usdc(), "uniswap_v2".to_string(), false, UserTransferType::TransferFrom, true, TransferType::None)]
// tokens are already in the router and don't need a transfer
#[case(weth(), usdc(), "vm:curve".to_string(), false, false, false, TransferType::None)]
#[case(weth(), usdc(), "vm:curve".to_string(), false, UserTransferType::TransferFrom, false, TransferType::None)]
fn test_get_transfers(
#[case] given_token: Bytes,
#[case] swap_token_in: Bytes,
#[case] protocol: String,
#[case] wrap: bool,
#[case] token_in_already_in_router: bool,
#[case] user_transfer_type: UserTransferType,
#[case] in_between_swap_optimization: bool,
#[case] expected_transfer: TransferType,
) {
@@ -192,7 +187,7 @@ mod tests {
swaps,
};
let optimization =
TransferOptimization::new(eth(), weth(), token_in_already_in_router, router_address());
TransferOptimization::new(eth(), weth(), user_transfer_type, router_address());
let transfer = optimization.get_transfers(
swap.clone(),
given_token,
@@ -224,7 +219,12 @@ mod tests {
#[case] expected_receiver: Bytes,
#[case] expected_optimization: bool,
) {
let optimization = TransferOptimization::new(eth(), weth(), false, router_address());
let optimization = TransferOptimization::new(
eth(),
weth(),
UserTransferType::TransferFrom,
router_address(),
);
let next_swap = if protocol.is_none() {
None

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

@@ -1,5 +1,6 @@
use std::{collections::HashSet, str::FromStr};
use alloy::signers::local::PrivateKeySigner;
use tycho_common::Bytes;
use crate::encoding::{
@@ -16,6 +17,7 @@ use crate::encoding::{
},
models::{
Chain, EncodedSolution, EncodingContext, NativeAction, Solution, Transaction, TransferType,
UserTransferType,
},
strategy_encoder::StrategyEncoder,
tycho_encoder::TychoEncoder,
@@ -24,37 +26,36 @@ use crate::encoding::{
/// Encodes solutions to be used by the TychoRouter.
///
/// # Fields
/// * `chain`: Chain to be used
/// * `single_swap_strategy`: Encoder for single swaps
/// * `sequential_swap_strategy`: Encoder for sequential swaps
/// * `split_swap_strategy`: Encoder for split swaps
/// * `native_address`: Address of the chain's native token
/// * `wrapped_address`: Address of the chain's wrapped native token
/// * `router_address`: Address of the Tycho router contract
/// * `token_in_already_in_router`: Indicates if the token in is already in the router at swap time
/// * `user_transfer_type`: Type of user transfer
/// * `permit2`: Optional Permit2 instance for permit transfers
/// * `signer`: Optional signer (used only for permit2 and full calldata encoding)
#[derive(Clone)]
pub struct TychoRouterEncoder {
chain: Chain,
single_swap_strategy: SingleSwapStrategyEncoder,
sequential_swap_strategy: SequentialSwapStrategyEncoder,
split_swap_strategy: SplitSwapStrategyEncoder,
native_address: Bytes,
wrapped_address: Bytes,
router_address: Bytes,
token_in_already_in_router: bool,
user_transfer_type: UserTransferType,
permit2: Option<Permit2>,
signer: Option<PrivateKeySigner>,
}
impl TychoRouterEncoder {
pub fn new(
chain: Chain,
swap_encoder_registry: SwapEncoderRegistry,
swapper_pk: Option<String>,
router_address: Bytes,
token_in_already_in_router: bool,
user_transfer_type: UserTransferType,
signer: Option<PrivateKeySigner>,
) -> Result<Self, EncodingError> {
let native_address = chain.native_token()?;
let wrapped_address = chain.wrapped_token()?;
let permit2 = if let Some(swapper_pk) = swapper_pk.clone() {
Some(Permit2::new(swapper_pk, chain.clone())?)
let permit2 = if user_transfer_type == UserTransferType::TransferFromPermit2 {
Some(Permit2::new()?)
} else {
None
};
@@ -62,29 +63,26 @@ impl TychoRouterEncoder {
single_swap_strategy: SingleSwapStrategyEncoder::new(
chain.clone(),
swap_encoder_registry.clone(),
permit2.is_some(),
user_transfer_type.clone(),
router_address.clone(),
token_in_already_in_router,
)?,
sequential_swap_strategy: SequentialSwapStrategyEncoder::new(
chain.clone(),
swap_encoder_registry.clone(),
permit2.is_some(),
user_transfer_type.clone(),
router_address.clone(),
token_in_already_in_router,
)?,
split_swap_strategy: SplitSwapStrategyEncoder::new(
chain,
chain.clone(),
swap_encoder_registry,
permit2.is_some(),
user_transfer_type.clone(),
router_address.clone(),
token_in_already_in_router,
)?,
native_address,
wrapped_address,
router_address,
token_in_already_in_router,
permit2,
signer,
chain,
user_transfer_type,
})
}
@@ -118,14 +116,13 @@ impl TychoRouterEncoder {
};
if let Some(permit2) = self.permit2.clone() {
let (permit, signature) = permit2.get_permit(
let permit = permit2.get_permit(
&self.router_address,
&solution.sender,
&solution.given_token,
&solution.given_amount,
)?;
encoded_solution.permit = Some(permit);
encoded_solution.signature = Some(signature.as_bytes().to_vec());
}
Ok(encoded_solution)
}
@@ -153,10 +150,12 @@ impl TychoEncoder for TychoRouterEncoder {
let encoded_solution = self.encode_solution(solution)?;
let transaction = encode_tycho_router_call(
self.chain.id,
encoded_solution,
solution,
self.token_in_already_in_router,
self.native_address.clone(),
self.user_transfer_type.clone(),
self.chain.native_token()?.clone(),
self.signer.clone(),
)?;
transactions.push(transaction);
@@ -184,15 +183,17 @@ impl TychoEncoder for TychoRouterEncoder {
if solution.swaps.is_empty() {
return Err(EncodingError::FatalError("No swaps found in solution".to_string()));
}
let native_address = self.chain.native_token()?;
let wrapped_address = self.chain.wrapped_token()?;
if let Some(native_action) = solution.clone().native_action {
if native_action == NativeAction::Wrap {
if solution.given_token != self.native_address {
if solution.given_token != native_address {
return Err(EncodingError::FatalError(
"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 != self.wrapped_address {
if first_swap.token_in != wrapped_address {
return Err(EncodingError::FatalError(
"Wrapped token must be the first swap's input in order to wrap"
.to_string(),
@@ -200,13 +201,13 @@ impl TychoEncoder for TychoRouterEncoder {
}
}
} else if native_action == NativeAction::Unwrap {
if solution.checked_token != self.native_address {
if solution.checked_token != native_address {
return Err(EncodingError::FatalError(
"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 != self.wrapped_address {
if last_swap.token_out != wrapped_address {
return Err(EncodingError::FatalError(
"Wrapped token must be the last swap's output in order to unwrap"
.to_string(),
@@ -337,7 +338,6 @@ impl TychoExecutorEncoder {
swaps: grouped_protocol_data,
interacting_with: executor_address,
permit: None,
signature: None,
selector: "".to_string(),
n_tokens: 0,
})
@@ -474,13 +474,14 @@ mod tests {
TychoRouterEncoder::new(
TychoCommonChain::Ethereum.into(),
get_swap_encoder_registry(),
None,
Bytes::from_str("0x3Ede3eCa2a72B3aeCC820E955B36f38437D01395").unwrap(),
false,
UserTransferType::TransferFrom,
None,
)
.unwrap()
}
#[test]
#[allow(deprecated)]
fn test_encode_router_calldata_single_swap() {
let encoder = get_tycho_router_encoder();
let eth_amount_in = BigUint::from(1000u32);
@@ -520,6 +521,7 @@ mod tests {
}
#[test]
#[allow(deprecated)]
fn test_encode_router_calldata_single_swap_group() {
let encoder = get_tycho_router_encoder();
let solution = Solution {
@@ -543,6 +545,7 @@ mod tests {
}
#[test]
#[allow(deprecated)]
fn test_encode_router_calldata_sequential_swap() {
let encoder = get_tycho_router_encoder();
let eth_amount_in = BigUint::from(1000u32);

28
src/encoding/models.rs
View File

@@ -1,3 +1,4 @@
use clap::ValueEnum;
use hex;
use num_bigint::BigUint;
use serde::{Deserialize, Serialize};
@@ -8,6 +9,31 @@ use tycho_common::{
use crate::encoding::{errors::EncodingError, serde_primitives::biguint_string};
/// Specifies the method for transferring user funds into Tycho execution.
///
/// Options:
///
/// - `TransferFromPermit2`: Use Permit2 for token transfer.
/// - You must manually approve the Permit2 contract and sign the permit object externally
/// (outside `tycho-execution`).
///
/// - `TransferFrom`: Use standard ERC-20 approval and `transferFrom`.
/// - You must approve the Tycho Router contract to spend your tokens via standard `approve()`
/// calls.
///
/// - `None`: No transfer will be performed.
/// - Assumes the tokens are already present in the Tycho Router.
/// - **Warning**: This is an advanced mode. Ensure your logic guarantees that the tokens are
/// already in the router at the time of execution.
/// - The Tycho router is **not** designed to safely hold tokens. If tokens are not transferred
/// and used in the **same transaction**, they will be permanently lost.
#[derive(Clone, Debug, PartialEq, ValueEnum)]
pub enum UserTransferType {
TransferFromPermit2,
TransferFrom,
None,
}
/// Represents a solution containing details describing an order, and instructions for filling
/// the order.
#[derive(Clone, Default, Debug, Deserialize, Serialize)]
@@ -95,7 +121,6 @@ pub struct Transaction {
/// * `selector`: The selector of the function to be called.
/// * `n_tokens`: Number of tokens in the swap.
/// * `permit`: Optional permit for the swap (if permit2 is enabled).
/// * `signature`: Optional signature for the swap (if permit2 is enabled).
#[derive(Clone, Debug)]
pub struct EncodedSolution {
pub swaps: Vec<u8>,
@@ -103,7 +128,6 @@ pub struct EncodedSolution {
pub selector: String,
pub n_tokens: usize,
pub permit: Option<PermitSingle>,
pub signature: Option<Vec<u8>>,
}
/// Represents a single permit for permit2.

1
src/encoding/tycho_encoder.rs
View File

@@ -61,6 +61,7 @@ pub trait TychoEncoder {
///
/// # Returns
/// A vector of fully constructed [`Transaction`]s that can be submitted to a node or bundler.
#[deprecated(note = "Please use `encode_solutions` instead")]
fn encode_full_calldata(
&self,
solutions: Vec<Solution>,