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

Merge pull request #42 from propeller-heads/encoding/dc/ENG-4087-example

Browse Source 
feat: Example
This commit is contained in:
dianacarvalho1
2025-02-04 09:22:50 +00:00
committed by GitHub
parent c4eb7b03b2 5143b16937
commit 8a8abf8d86
17 changed files with 255 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
examples/quickstart/Readme.md Normal file
View File

@@ -0,0 +1,12 @@
# QuickStart
This quickstart guide enables you to:
1. Create a Solution object
2. Encode the solution to interact with the Ethereum blockchain
## How to run
```bash
cargo run --release --example quickstart
```

149
examples/quickstart/main.rs Normal file
View File

@@ -0,0 +1,149 @@
use std::str::FromStr;
use num_bigint::BigUint;
use tycho_core::{dto::ProtocolComponent, models::Chain, Bytes};
use tycho_execution::encoding::{
evm::{
strategy_encoder::strategy_selector::EVMStrategySelector, tycho_encoder::EVMTychoEncoder,
},
models::{Solution, Swap},
tycho_encoder::TychoEncoder,
};
fn main() {
// Setup variables
let router_address = "0x1234567890abcdef1234567890abcdef12345678".to_string();
let signer_pk =
Some("0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string());
let user_address = Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2")
.expect("Failed to create user address");
// Initialize the encoder
let encoder =
EVMTychoEncoder::new(EVMStrategySelector, router_address, signer_pk, Chain::Ethereum)
.expect("Failed to create encoder");
// ------------------- Encode a simple swap -------------------
// Prepare data to encode. We will encode a simple swap from WETH to USDC
// First we need to create a swap object
let weth = Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")
.expect("Failed to create WETH address");
let usdc = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
.expect("Failed to create USDC address");
let simple_swap = Swap {
// The protocol component data comes from tycho-indexer
component: ProtocolComponent {
id: "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: usdc.clone(),
// Split defines the fraction of the amount to be swapped. A value of 0 indicates 100% of
// the amount or the total remaining balance.
split: 0f64,
};
// Then we create a solution object with the previous swap
let solution = Solution {
sender: user_address.clone(),
receiver: user_address.clone(),
given_token: weth.clone(),
given_amount: BigUint::from_str("1_000000000000000000").expect("Failed to create amount"),
checked_token: usdc.clone(),
exact_out: false, // it's an exact in solution
check_amount: None, // the amount out will not be checked in execution
swaps: vec![simple_swap],
..Default::default()
};
// Encode the solution
let tx = encoder
.encode_router_calldata(vec![solution.clone()])
.expect("Failed to encode router calldata")[0]
.clone();
println!(" ====== Simple swap WETH -> USDC ======");
println!(
"The simple swap encoded transaction should be sent to address {:?} with the value of {:?} and the \
following encoded data: {:?}",
tx.to,
tx.value,
hex::encode(tx.data)
);
// ------------------- Encode a swap with multiple splits -------------------
// To illustrate a more complex solution, we will encode a swap from WETH to USDC with multiple
// splits. Performs a split swap from WETH to USDC though WBTC and DAI using USV2 pools
//
// ┌──(USV2)──> WBTC ───(USV2)──> USDC
// WETH ─┤
// └──(USV2)──> DAI ───(USV2)──> USDC
//
let wbtc = Bytes::from_str("0x2260fac5e5542a773aa44fbcfedf7c193bc2c599")
.expect("Failed to create WBTC address");
let dai = Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f")
.expect("Failed to create DAI address");
let swap_weth_dai = Swap {
component: ProtocolComponent {
id: "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: dai.clone(),
split: 0.5f64,
};
let swap_weth_wbtc = Swap {
component: ProtocolComponent {
id: "0xBb2b8038a1640196FbE3e38816F3e67Cba72D940".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: weth.clone(),
token_out: wbtc.clone(),
// This represents the remaining 50%, but to avoid any rounding errors we set this to
// 0 to signify "the remainder of the WETH value". It should still be very close to 50%
split: 0f64,
};
let swap_dai_usdc = Swap {
component: ProtocolComponent {
id: "0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: dai.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let swap_wbtc_usdc = Swap {
component: ProtocolComponent {
id: "0x004375Dff511095CC5A197A54140a24eFEF3A416".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: wbtc.clone(),
token_out: usdc.clone(),
split: 0f64,
};
let mut complex_solution = solution.clone();
complex_solution.swaps = vec![swap_weth_dai, swap_weth_wbtc, swap_dai_usdc, swap_wbtc_usdc];
// Encode the solution
let complex_tx = encoder
.encode_router_calldata(vec![complex_solution])
.expect("Failed to encode router calldata")[0]
.clone();
println!(" ====== Complex split swap WETH -> USDC ======");
println!(
"The complex solution encoded transaction should be sent to address {:?} with the value of {:?} and the \
following encoded data: {:?}",
complex_tx.to,
complex_tx.value,
hex::encode(complex_tx.data)
);
}

1
src/encoding/errors.rs
View File

@@ -13,7 +13,6 @@ use thiserror::Error;
/// at a later time may succeed. It may have failed due to a temporary issue, such as a network
/// problem.
#[derive(Error, Debug, PartialEq)]
#[allow(dead_code)]
pub enum EncodingError {
#[error("Invalid input: {0}")]
InvalidInput(String),

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

@@ -60,7 +60,6 @@ sol! {
}
}
#[allow(dead_code)]
impl Permit2 {
pub fn new(signer_pk: String, chain: Chain) -> Result<Self, EncodingError> {
let chain_id = ChainId::from(chain);

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

@@ -12,7 +12,6 @@ use tokio::runtime::Runtime;
use crate::encoding::{errors::EncodingError, evm::utils::encode_input};
#[allow(dead_code)]
pub struct ProtocolApprovalsManager {
client: Arc<RootProvider<BoxTransport>>,
runtime: Runtime,

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

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

155
src/encoding/evm/strategy_encoder/encoder.rs
View File

@@ -1,155 +0,0 @@
use std::str::FromStr;
use alloy_primitives::Address;
use alloy_sol_types::SolValue;
use tycho_core::Bytes;
use crate::encoding::{
errors::EncodingError,
evm::swap_encoder::SWAP_ENCODER_REGISTRY,
models::{EncodingContext, Solution},
strategy_encoder::StrategyEncoder,
};
#[allow(dead_code)]
pub trait EVMStrategyEncoder: StrategyEncoder {
fn encode_protocol_header(
&self,
protocol_data: Vec<u8>,
executor_address: Address,
// Token indices, split, and token inclusion are only used for split swaps
token_in: u16,
token_out: u16,
split: u16, // not sure what should be the type of this :/
) -> Vec<u8> {
let args = (executor_address, token_in, token_out, split, protocol_data);
args.abi_encode()
}
}
pub struct SplitSwapStrategyEncoder {}
impl EVMStrategyEncoder for SplitSwapStrategyEncoder {}
impl StrategyEncoder for SplitSwapStrategyEncoder {
fn encode_strategy(&self, _solution: Solution) -> Result<(Vec<u8>, Bytes), EncodingError> {
todo!()
}
fn selector(&self, _exact_out: bool) -> &str {
"swap(uint256, address, uint256, bytes[])"
}
}
/// This strategy encoder is used for solutions that are sent directly to the pool.
/// Only 1 solution with 1 swap is supported.
pub struct ExecutorStrategyEncoder {}
impl EVMStrategyEncoder for ExecutorStrategyEncoder {}
impl StrategyEncoder for ExecutorStrategyEncoder {
fn encode_strategy(&self, solution: Solution) -> Result<(Vec<u8>, Bytes), EncodingError> {
if solution.router_address.is_none() {
return Err(EncodingError::InvalidInput(
"Router address is required for straight to pool solutions".to_string(),
));
}
let swap = solution.swaps.first().unwrap();
let registry = SWAP_ENCODER_REGISTRY
.read()
.map_err(|_| {
EncodingError::FatalError("Failed to read the swap encoder registry".to_string())
})?;
let swap_encoder = registry
.get_encoder(&swap.component.protocol_system)
.ok_or_else(|| {
EncodingError::InvalidInput(format!(
"Swap encoder not found for protocol: {}",
swap.component.protocol_system
))
})?;
let router_address = solution.router_address.unwrap();
let encoding_context = EncodingContext {
receiver: solution.receiver,
exact_out: solution.exact_out,
router_address,
};
let protocol_data = swap_encoder.encode_swap(swap.clone(), encoding_context)?;
let executor_address = Bytes::from_str(swap_encoder.executor_address())
.map_err(|_| EncodingError::FatalError("Invalid executor address".to_string()))?;
Ok((protocol_data, executor_address))
}
fn selector(&self, _exact_out: bool) -> &str {
"swap(uint256, bytes)"
}
}
#[cfg(test)]
mod tests {
use alloy::hex::encode;
use num_bigint::BigUint;
use tycho_core::{dto::ProtocolComponent, Bytes};
use super::*;
use crate::encoding::models::Swap;
#[test]
fn test_executor_strategy_encode() {
let encoder = ExecutorStrategyEncoder {};
let token_in = Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
let token_out = Bytes::from("0x6b175474e89094c44da98b954eedeac495271d0f");
let swap = Swap {
component: ProtocolComponent {
id: "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11".to_string(),
protocol_system: "uniswap_v2".to_string(),
..Default::default()
},
token_in: token_in.clone(),
token_out: token_out.clone(),
split: 0f64,
};
let solution = Solution {
exact_out: false,
given_token: token_in,
given_amount: BigUint::from(1000000000000000000u64),
expected_amount: BigUint::from(1000000000000000000u64),
checked_token: token_out,
check_amount: None,
sender: Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap(),
// The receiver was generated with `makeAddr("bob") using forge`
receiver: Bytes::from_str("0x1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e").unwrap(),
swaps: vec![swap],
direct_execution: true,
router_address: Some(Bytes::zero(20)),
slippage: None,
native_action: None,
};
let (protocol_data, executor_address) = encoder
.encode_strategy(solution)
.unwrap();
let hex_protocol_data = encode(&protocol_data);
assert_eq!(
executor_address,
Bytes::from_str("0x5c2f5a71f67c01775180adc06909288b4c329308").unwrap()
);
assert_eq!(
hex_protocol_data,
String::from(concat!(
// in token
"c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
// component id
"a478c2975ab1ea89e8196811f51a7b7ade33eb11",
// receiver
"1d96f2f6bef1202e4ce1ff6dad0c2cb002861d3e",
// zero for one
"00",
))
);
}
#[test]
fn test_selector() {
let encoder = ExecutorStrategyEncoder {};
assert_eq!(encoder.selector(false), "swap(uint256, bytes)");
}
}

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

@@ -1,2 +1,2 @@
mod strategy_encoders;
mod strategy_selector;
pub mod strategy_selector;

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

@@ -16,7 +16,6 @@ use crate::encoding::{
strategy_encoder::StrategyEncoder,
};
#[allow(dead_code)]
pub trait EVMStrategyEncoder: StrategyEncoder {
fn encode_swap_header(
&self,
@@ -77,16 +76,18 @@ impl StrategyEncoder for SplitSwapStrategyEncoder {
&solution.given_token,
&solution.given_amount,
)?;
let mut min_amount_out = BigUint::ZERO;
if let Some(user_specified_min_amount) = solution.check_amount {
if let Some(slippage) = solution.slippage {
let one_hundred = BigUint::from(100u32);
let slippage_percent = BigUint::from((slippage * 100.0) as u32);
let multiplier = &one_hundred - slippage_percent;
let expected_amount_with_slippage =
(&solution.expected_amount * multiplier) / one_hundred;
min_amount_out = max(user_specified_min_amount, expected_amount_with_slippage);
}
let mut min_amount_out = solution
.check_amount
.unwrap_or(BigUint::ZERO);
if let (Some(expected_amount), Some(slippage)) =
(solution.expected_amount.as_ref(), solution.slippage)
{
let one_hundred = BigUint::from(100u32);
let slippage_percent = BigUint::from((slippage * 100.0) as u32);
let multiplier = &one_hundred - slippage_percent;
let expected_amount_with_slippage = (expected_amount * &multiplier) / &one_hundred;
min_amount_out = max(min_amount_out, expected_amount_with_slippage);
}
// The tokens array is composed of the given token, the checked token and all the
// intermediary tokens in between. The contract expects the tokens to be in this order.
@@ -244,6 +245,7 @@ mod tests {
use alloy::hex::encode;
use num_bigint::BigUint;
use rstest::rstest;
use tycho_core::{dto::ProtocolComponent, Bytes};
use super::*;
@@ -271,7 +273,7 @@ mod tests {
exact_out: false,
given_token: token_in,
given_amount: BigUint::from(1000000000000000000u64),
expected_amount: BigUint::from(1000000000000000000u64),
expected_amount: Some(BigUint::from(1000000000000000000u64)),
checked_token: token_out,
check_amount: None,
sender: Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap(),
@@ -307,8 +309,37 @@ mod tests {
);
}
#[test]
fn test_split_swap_strategy_encoder_simple_route() {
#[rstest]
#[case::no_check_no_slippage(
None,
None,
None,
U256::from_str("0").unwrap(),
)]
#[case::with_check_no_slippage(
None,
None,
Some(BigUint::from_str("3_000_000000000000000000").unwrap()),
U256::from_str("3_000_000000000000000000").unwrap(),
)]
#[case::no_check_with_slippage(
Some(BigUint::from_str("3_000_000000000000000000").unwrap()),
Some(0.01f64),
None,
U256::from_str("2_970_000000000000000000").unwrap(),
)]
#[case::with_check_and_slippage(
Some(BigUint::from_str("3_000_000000000000000000").unwrap()),
Some(0.01f64),
Some(BigUint::from_str("2_999_000000000000000000").unwrap()),
U256::from_str("2_999_000000000000000000").unwrap(),
)]
fn test_split_swap_strategy_encoder_simple_route(
#[case] expected_amount: Option<BigUint>,
#[case] slippage: Option<f64>,
#[case] check_amount: Option<BigUint>,
#[case] expected_min_amount: U256,
) {
// Performs a single swap from WETH to DAI on a USV2 pool
// Set up a mock private key for signing
@@ -335,8 +366,9 @@ mod tests {
given_token: weth,
given_amount: BigUint::from_str("1_000000000000000000").unwrap(),
checked_token: dai,
expected_amount: BigUint::from_str("3_000_000000000000000000").unwrap(),
check_amount: None,
expected_amount,
slippage,
check_amount,
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
swaps: vec![swap],
@@ -347,18 +379,20 @@ mod tests {
let (calldata, _) = encoder
.encode_strategy(solution, router_address)
.unwrap();
let expected_min_amount_encoded = hex::encode(U256::abi_encode(&expected_min_amount));
let expected_input = [
"4860f9ed", // Function selector
"0000000000000000000000000000000000000000000000000de0b6b3a7640000", // amount out
"000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // token in
"0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f", // token out
&expected_min_amount_encoded, // min amount out
"0000000000000000000000000000000000000000000000000000000000000000", // wrap
"0000000000000000000000000000000000000000000000000000000000000000", // unwrap
"0000000000000000000000000000000000000000000000000000000000000002", // tokens length
"000000000000000000000000cd09f75e2bf2a4d11f3ab23f1389fcc1621c0cc2", // receiver
]
.join("");
let expected_input = String::from(concat!(
"4860f9ed",
"0000000000000000000000000000000000000000000000000de0b6b3a7640000", // amount out
"000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // token in
"0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f", // token out
"0000000000000000000000000000000000000000000000000000000000000000", // min amount out
"0000000000000000000000000000000000000000000000000000000000000000", // wrap
"0000000000000000000000000000000000000000000000000000000000000000", // unwrap
"0000000000000000000000000000000000000000000000000000000000000002", // tokens length
"000000000000000000000000cd09f75e2bf2a4d11f3ab23f1389fcc1621c0cc2", // receiver
));
// after this there is the permit and because of the deadlines (that depend on block time)
// it's hard to assert
// "000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // token in
@@ -473,7 +507,7 @@ mod tests {
given_token: weth,
given_amount: BigUint::from_str("1_000000000000000000").unwrap(),
checked_token: usdc,
expected_amount: BigUint::from_str("3_000_000000").unwrap(),
expected_amount: Some(BigUint::from_str("3_000_000000").unwrap()),
check_amount: None,
sender: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),
receiver: Bytes::from_str("0xcd09f75E2BF2A4d11F3AB23f1389FcC1621c0cc2").unwrap(),

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

@@ -10,25 +10,23 @@ use crate::encoding::{
tycho_encoder::TychoEncoder,
};
#[allow(dead_code)]
pub struct EVMTychoEncoder<S: StrategySelector> {
strategy_selector: S,
signer: Option<String>,
signer_pk: Option<String>,
chain: Chain,
router_address: Bytes,
}
#[allow(dead_code)]
impl<S: StrategySelector> EVMTychoEncoder<S> {
pub fn new(
strategy_selector: S,
router_address: String,
signer: Option<String>,
signer_pk: Option<String>,
chain: Chain,
) -> Result<Self, EncodingError> {
let router_address = Bytes::from_str(&router_address)
.map_err(|_| EncodingError::FatalError("Invalid router address".to_string()))?;
Ok(EVMTychoEncoder { strategy_selector, signer, chain, router_address })
Ok(EVMTychoEncoder { strategy_selector, signer_pk, chain, router_address })
}
}
impl<S: StrategySelector> TychoEncoder<S> for EVMTychoEncoder<S> {
@@ -51,7 +49,7 @@ impl<S: StrategySelector> TychoEncoder<S> for EVMTychoEncoder<S> {
let strategy = self.strategy_selector.select_strategy(
solution,
self.signer.clone(),
self.signer_pk.clone(),
self.chain,
)?;
let (contract_interaction, target_address) =

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

@@ -16,13 +16,11 @@ pub fn bytes_to_address(address: &Bytes) -> Result<Address, EncodingError> {
}
}
#[allow(dead_code)]
pub fn biguint_to_u256(value: &BigUint) -> U256 {
let bytes = value.to_bytes_be();
U256::from_be_slice(&bytes)
}
#[allow(dead_code)]
pub fn encode_input(selector: &str, mut encoded_args: Vec<u8>) -> Vec<u8> {
let mut hasher = Keccak256::new();
hasher.update(selector.as_bytes());

6
src/encoding/mod.rs
View File

@@ -1,7 +1,7 @@
mod errors;
#[cfg(feature = "evm")]
mod evm;
mod models;
pub mod evm;
pub mod models;
mod strategy_encoder;
mod swap_encoder;
mod tycho_encoder;
pub mod tycho_encoder;

42
src/encoding/models.rs
View File

@@ -2,48 +2,46 @@ use num_bigint::BigUint;
use tycho_core::{dto::ProtocolComponent, Bytes};
#[derive(Clone, Default, Debug)]
#[allow(dead_code)]
pub struct Solution {
/// True if the solution is an exact output solution.
pub exact_out: bool,
/// Address of the sender.
pub sender: Bytes,
/// Address of the receiver.
pub receiver: Bytes,
/// The token being sold (exact in) or bought (exact out).
pub given_token: Bytes,
/// Amount of the given token.
pub given_amount: BigUint,
/// The token being bought (exact in) or sold (exact out).
pub checked_token: Bytes,
/// False if the solution is an exact input solution. Currently only exact input solutions are
/// supported.
pub exact_out: bool,
// If set, it will be applied to expected_amount
pub slippage: Option<f64>,
/// Expected amount of the bought token (exact in) or sold token (exact out).
pub expected_amount: BigUint,
pub expected_amount: Option<BigUint>,
/// Minimum amount to be checked for the solution to be valid.
/// If not set, the check will not be performed.
pub check_amount: Option<BigUint>,
/// Address of the sender.
pub sender: Bytes,
/// Address of the receiver.
pub receiver: Bytes,
/// List of swaps to fulfill the solution.
pub swaps: Vec<Swap>,
// If not set, then the Tycho Router will be used
pub router_address: Option<Bytes>,
// If set, the corresponding native action will be executed.
pub native_action: Option<NativeAction>,
/// If set to true, the solution will be encoded to be sent directly to the Executor and
/// skip the router. The user is responsible for managing necessary approvals and token
/// transfers.
pub direct_execution: bool,
// if not set, then the Propeller Router will be used
pub router_address: Option<Bytes>,
// if set, it will be applied to check_amount
pub slippage: Option<f64>,
// if set, the corresponding native action will be executed
pub native_action: Option<NativeAction>,
}
#[derive(Clone, PartialEq, Debug)]
#[allow(dead_code)]
pub enum NativeAction {
Wrap,
Unwrap,
}
#[derive(Clone, Debug)]
#[allow(dead_code)]
pub struct Swap {
/// Protocol component from tycho indexer
pub component: ProtocolComponent,
@@ -51,20 +49,20 @@ pub struct Swap {
pub token_in: Bytes,
/// Token being output from the pool.
pub token_out: Bytes,
/// Percentage of the amount to be swapped in this operation.
/// Percentage of the amount to be swapped in this operation (for example, 0.5 means 50%)
pub split: f64,
}
#[allow(dead_code)]
#[derive(Clone, Debug)]
pub struct Transaction {
pub data: Vec<u8>,
// ETH value to be sent with the transaction.
pub value: BigUint,
// Address of the contract to call with the calldata
pub to: Bytes,
// ETH value to be sent with the transaction.
pub value: BigUint,
// Encoded calldata for the transaction.
pub data: Vec<u8>,
}
#[allow(dead_code)]
pub struct EncodingContext {
pub receiver: Bytes,
pub exact_out: bool,

2
src/encoding/strategy_encoder.rs
View File

@@ -2,7 +2,6 @@ use tycho_core::{models::Chain, Bytes};
use crate::encoding::{errors::EncodingError, models::Solution};
#[allow(dead_code)]
pub trait StrategyEncoder {
fn encode_strategy(
&self,
@@ -12,7 +11,6 @@ pub trait StrategyEncoder {
}
pub trait StrategySelector {
#[allow(dead_code)]
fn select_strategy(
&self,
solution: &Solution,

1
src/encoding/swap_encoder.rs
View File

@@ -2,7 +2,6 @@ use crate::encoding::{
errors::EncodingError,
models::{EncodingContext, Swap},
};
#[allow(dead_code)]
pub trait SwapEncoder: Sync + Send {
fn new(executor_address: String) -> Self

1
src/encoding/tycho_encoder.rs
View File

@@ -4,7 +4,6 @@ use crate::encoding::{
strategy_encoder::StrategySelector,
};
#[allow(dead_code)]
pub trait TychoEncoder<S: StrategySelector> {
fn encode_router_calldata(
&self,

2
src/lib.rs
View File

@@ -1 +1 @@
mod encoding;
pub mod encoding;