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

feat: Take Chain object containing native/wrapped addresses

Browse Source 
- This way this chain object contains everything we need, we don't need to worry about doing any transformation or calling any supplementary functions inside any of the encoders
- Needed to move our new Chain object to a higher level since this is used in the higher-level encoder traits. This required some weird default values in the constants in order to avoid using alloy's hex literal. I could have instead opted to make Bytes parse a string I think, though this would mean possibly returning an error at the constants level, which is not nice either.

Question:
- Do we want the user to be in charge of passing the native and wrapped token every single time? This may be a bit annoying for the user. For now, I have defaulted to those in constants.rs, this would take 5 mins to remove though if you don't like it, and it would get rid of this complicated bytes initialization.
This commit is contained in:
TAMARA LIPOWSKI
2025-02-05 15:33:20 -05:00
parent f8b3baff55
commit e83b8d9aef
15 changed files with 190 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -4242,6 +4242,7 @@ dependencies = [
"lazy_static",
"num-bigint",
"num-traits",
"once_cell",
"rstest",
"serde",
"serde_json",

1
Cargo.toml
View File

@@ -19,6 +19,7 @@ alloy = { version = "0.9.2", features = ["providers", "rpc-types-eth", "eip712",
alloy-sol-types = { version = "0.8.14", optional = true }
alloy-primitives = { version = "0.8.9", optional = true }
tycho-core = { git = "https://github.com/propeller-heads/tycho-indexer.git", package = "tycho-core", tag = "0.46.0" }
once_cell = "1.20.2"
[dev-dependencies]
rstest = "0.24.0"

10
examples/quickstart/main.rs
View File

@@ -2,7 +2,7 @@ use std::str::FromStr;
use num_bigint::BigUint;
use tycho_core::{
dto::{Chain, ProtocolComponent},
dto::{Chain as TychoCoreChain, ProtocolComponent},
Bytes,
};
use tycho_execution::encoding::{
@@ -10,7 +10,7 @@ use tycho_execution::encoding::{
strategy_encoder::strategy_encoder_registry::EVMStrategyEncoderRegistry,
tycho_encoder::EVMTychoEncoder,
},
models::{Solution, Swap},
models::{Chain, Solution, Swap},
strategy_encoder::StrategyEncoderRegistry,
tycho_encoder::TychoEncoder,
};
@@ -24,11 +24,13 @@ fn main() {
.expect("Failed to create user address");
let executors_file_path = "src/encoding/config/executor_addresses.json";
let eth_chain = Chain::from_tycho_core_chain(TychoCoreChain::Ethereum, None, None)
.expect("Failed to create chain.");
// Initialize the encoder
let strategy_encoder_registry =
EVMStrategyEncoderRegistry::new(Chain::Ethereum, executors_file_path, signer_pk.clone())
EVMStrategyEncoderRegistry::new(eth_chain.clone(), executors_file_path, signer_pk.clone())
.expect("Failed to create strategy encoder registry");
let encoder = EVMTychoEncoder::new(strategy_encoder_registry, router_address, Chain::Ethereum)
let encoder = EVMTychoEncoder::new(strategy_encoder_registry, router_address, eth_chain)
.expect("Failed to create encoder");
// ------------------- Encode a simple swap -------------------

19
src/encoding/constants.rs Normal file
View File

@@ -0,0 +1,19 @@
use std::collections::HashMap;
use once_cell::sync::Lazy;
use tycho_core::{dto::Chain, Bytes};
const ETH_NATIVE: &[u8] = &[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
];
const ETH_WRAPPED: &[u8] = &[
0xc0, 0x2a, 0xaa, 0x39, 0xb2, 0x23, 0xfe, 0x8d, 0x0a, 0x0e, 0x5c, 0x4f, 0x27, 0xea, 0xd9, 0x08,
0x3c, 0x75, 0x6c, 0xc2,
];
pub static NATIVE_ADDRESSES: Lazy<HashMap<Chain, Bytes>> =
Lazy::new(|| HashMap::from([(Chain::Ethereum, Bytes::from(ETH_NATIVE))]));
pub static WRAPPED_ADDRESSES: Lazy<HashMap<Chain, Bytes>> =
Lazy::new(|| HashMap::from([(Chain::Ethereum, Bytes::from(ETH_WRAPPED))]));

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

@@ -12,15 +12,15 @@ use alloy_sol_types::{eip712_domain, sol, SolStruct, SolValue};
use chrono::Utc;
use num_bigint::BigUint;
use tokio::runtime::Runtime;
use tycho_core::{dto::Chain, Bytes};
use tycho_core::Bytes;
use crate::encoding::{
errors::EncodingError,
evm::{
approvals::protocol_approvals_manager::get_client,
models::ChainId,
utils::{biguint_to_u256, bytes_to_address, encode_input},
},
models::{Chain, ChainId},
};
/// Struct for managing Permit2 operations, including encoding approvals and fetching allowance
@@ -60,7 +60,6 @@ sol! {
impl Permit2 {
pub fn new(signer_pk: String, chain: Chain) -> Result<Self, EncodingError> {
let chain_id = ChainId::from(chain);
let runtime = Runtime::new()
.map_err(|_| EncodingError::FatalError("Failed to create runtime".to_string()))?;
let client = runtime.block_on(get_client())?;
@@ -76,7 +75,7 @@ impl Permit2 {
client,
runtime,
signer,
chain_id,
chain_id: chain.id,
})
}
@@ -199,11 +198,28 @@ mod tests {
}
}
fn eth() -> Bytes {
Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap()
}
fn weth() -> Bytes {
Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()
}
fn eth_chain() -> Chain {
Chain {
id: ChainId(1),
name: String::from("ethereum"),
native_token: eth(),
wrapped_token: weth(),
}
}
#[test]
fn test_get_existing_allowance() {
let signer_pk =
"4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
let manager = Permit2::new(signer_pk, Chain::Ethereum).unwrap();
let manager = Permit2::new(signer_pk, eth_chain()).unwrap();
let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
@@ -223,7 +239,7 @@ mod tests {
// Set up a mock private key for signing
let private_key =
"4c0883a69102937d6231471b5dbb6204fe512961708279feb1be6ae5538da033".to_string();
let permit2 = Permit2::new(private_key, Chain::Ethereum).expect("Failed to create Permit2");
let permit2 = Permit2::new(private_key, eth_chain()).expect("Failed to create Permit2");
let owner = Bytes::from_str("0x2c6a3cd97c6283b95ac8c5a4459ebb0d5fd404f4").unwrap();
let spender = Bytes::from_str("0xba12222222228d8ba445958a75a0704d566bf2c8").unwrap();
@@ -264,7 +280,7 @@ mod tests {
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".to_string();
let permit2 =
Permit2::new(anvil_private_key, Chain::Ethereum).expect("Failed to create Permit2");
Permit2::new(anvil_private_key, eth_chain()).expect("Failed to create Permit2");
let token = Bytes::from_str("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").unwrap();
let amount = BigUint::from(1000u64);

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

@@ -1,18 +0,0 @@
use alloy_primitives::hex;
use tycho_core::{dto::Chain, Bytes};
pub fn native_address(chain: Chain) -> Bytes {
match chain {
Chain::Ethereum => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
// Placeholder values for other chains; update with real addresses
_ => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
}
}
pub fn wrapped_address(chain: Chain) -> Bytes {
match chain {
Chain::Ethereum => Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec()),
// Placeholder values for other chains; update with real addresses
_ => Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec()),
}
}

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

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

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

@@ -1,20 +0,0 @@
use tycho_core::dto::Chain;
pub struct ChainId(u64);
impl ChainId {
pub fn id(&self) -> u64 {
self.0
}
}
impl From<Chain> for ChainId {
fn from(chain: Chain) -> Self {
match chain {
Chain::Ethereum => ChainId(1),
Chain::ZkSync => ChainId(324),
Chain::Arbitrum => ChainId(42161),
Chain::Starknet => ChainId(0),
}
}
}

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

@@ -1,14 +1,12 @@
use std::collections::HashMap;
use tycho_core::dto::Chain;
use crate::encoding::{
errors::EncodingError,
evm::{
strategy_encoder::strategy_encoders::{ExecutorStrategyEncoder, SplitSwapStrategyEncoder},
swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
},
models::Solution,
models::{Chain, Solution},
strategy_encoder::{StrategyEncoder, StrategyEncoderRegistry},
};
@@ -22,7 +20,7 @@ impl StrategyEncoderRegistry for EVMStrategyEncoderRegistry {
executors_file_path: &str,
signer_pk: Option<String>,
) -> Result<Self, EncodingError> {
let swap_encoder_registry = SwapEncoderRegistry::new(executors_file_path, Chain::Ethereum)?;
let swap_encoder_registry = SwapEncoderRegistry::new(executors_file_path, chain.clone())?;
let mut strategies: HashMap<String, Box<dyn StrategyEncoder>> = HashMap::new();
strategies.insert(

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

@@ -7,17 +7,16 @@ use std::{
use alloy_primitives::{aliases::U24, FixedBytes, U256, U8};
use alloy_sol_types::SolValue;
use num_bigint::BigUint;
use tycho_core::{dto::Chain, keccak256, Bytes};
use tycho_core::{keccak256, Bytes};
use crate::encoding::{
errors::EncodingError,
evm::{
approvals::permit2::Permit2,
constants::{native_address, wrapped_address},
swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
utils::{biguint_to_u256, bytes_to_address, encode_input, percentage_to_uint24},
},
models::{EncodingContext, NativeAction, Solution, Swap},
models::{Chain, EncodingContext, NativeAction, Solution, Swap},
strategy_encoder::StrategyEncoder,
swap_encoder::SwapEncoder,
};
@@ -62,8 +61,8 @@ pub struct SplitSwapStrategyEncoder {
swap_encoder_registry: SwapEncoderRegistry,
permit2: Permit2,
selector: String,
wrapped_address: Bytes,
native_address: Bytes,
wrapped_address: Bytes,
}
impl SplitSwapStrategyEncoder {
@@ -73,14 +72,12 @@ impl SplitSwapStrategyEncoder {
swap_encoder_registry: SwapEncoderRegistry,
) -> Result<Self, EncodingError> {
let selector = "swap(uint256,address,address,uint256,bool,bool,uint256,address,((address,uint160,uint48,uint48),address,uint256),bytes,bytes)".to_string();
let wrapped_address = wrapped_address(chain);
let native_address = native_address(chain);
Ok(Self {
permit2: Permit2::new(signer_pk, chain)?,
permit2: Permit2::new(signer_pk, chain.clone())?,
selector,
swap_encoder_registry,
wrapped_address,
native_address,
native_address: chain.native_token.clone(),
wrapped_address: chain.wrapped_token.clone(),
})
}
@@ -434,26 +431,37 @@ mod tests {
use std::str::FromStr;
use alloy::hex::encode;
use alloy_primitives::hex;
use num_bigint::BigUint;
use rstest::rstest;
use tycho_core::{dto::ProtocolComponent, Bytes};
use tycho_core::{
dto::{Chain as TychoCoreChain, ProtocolComponent},
Bytes,
};
use super::*;
use crate::encoding::{
evm::constants::{native_address, wrapped_address},
models::Swap,
};
use crate::encoding::models::{ChainId, Swap};
fn eth_chain() -> Chain {
Chain {
id: ChainId(1),
name: TychoCoreChain::Ethereum.to_string(),
native_token: eth(),
wrapped_token: weth(),
}
}
fn eth() -> Bytes {
native_address(Chain::Ethereum)
Bytes::from(hex!("0000000000000000000000000000000000000000").to_vec())
}
fn weth() -> Bytes {
wrapped_address(Chain::Ethereum)
Bytes::from(hex!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").to_vec())
}
fn get_swap_encoder_registry() -> SwapEncoderRegistry {
SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", Chain::Ethereum)
.unwrap()
let eth_chain = eth_chain();
SwapEncoderRegistry::new("src/encoding/config/executor_addresses.json", eth_chain).unwrap()
}
#[test]
@@ -567,8 +575,7 @@ mod tests {
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
.unwrap();
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let solution = Solution {
exact_out: false,
given_token: weth,
@@ -669,8 +676,7 @@ mod tests {
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
.unwrap();
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let solution = Solution {
exact_out: false,
given_token: eth(),
@@ -718,8 +724,7 @@ mod tests {
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
.unwrap();
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let solution = Solution {
exact_out: false,
given_token: dai,
@@ -808,8 +813,7 @@ mod tests {
};
let swap_encoder_registry = get_swap_encoder_registry();
let encoder =
SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry)
.unwrap();
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap();
let solution = Solution {
exact_out: false,
given_token: weth,
@@ -836,7 +840,7 @@ mod tests {
let private_key =
"0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef1234".to_string();
let swap_encoder_registry = get_swap_encoder_registry();
SplitSwapStrategyEncoder::new(private_key, Chain::Ethereum, swap_encoder_registry).unwrap()
SplitSwapStrategyEncoder::new(private_key, eth_chain(), swap_encoder_registry).unwrap()
}
#[test]

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

@@ -1,9 +1,7 @@
use std::{collections::HashMap, fs};
use tycho_core::dto::Chain;
use crate::encoding::{
errors::EncodingError, evm::swap_encoder::builder::SwapEncoderBuilder,
errors::EncodingError, evm::swap_encoder::builder::SwapEncoderBuilder, models::Chain,
swap_encoder::SwapEncoder,
};
@@ -15,10 +13,10 @@ pub struct SwapEncoderRegistry {
impl SwapEncoderRegistry {
pub fn new(executors_file_path: &str, blockchain: Chain) -> Result<Self, EncodingError> {
let config_str = fs::read_to_string(executors_file_path)?;
let config: HashMap<Chain, HashMap<String, String>> = serde_json::from_str(&config_str)?;
let config: HashMap<String, HashMap<String, String>> = serde_json::from_str(&config_str)?;
let mut encoders = HashMap::new();
let executors = config
.get(&blockchain)
.get(&blockchain.name)
.ok_or(EncodingError::FatalError("No executors found for blockchain".to_string()))?;
for (protocol, executor_address) in executors {
let builder = SwapEncoderBuilder::new(protocol, executor_address);

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

@@ -1,12 +1,11 @@
use std::str::FromStr;
use num_bigint::BigUint;
use tycho_core::{dto::Chain, Bytes};
use tycho_core::Bytes;
use crate::encoding::{
errors::EncodingError,
evm::constants::{native_address, wrapped_address},
models::{NativeAction, Solution, Transaction},
models::{Chain, NativeAction, Solution, Transaction},
strategy_encoder::StrategyEncoderRegistry,
tycho_encoder::TychoEncoder,
};
@@ -26,14 +25,17 @@ impl<S: StrategyEncoderRegistry> EVMTychoEncoder<S> {
) -> Result<Self, EncodingError> {
let router_address = Bytes::from_str(&router_address)
.map_err(|_| EncodingError::FatalError("Invalid router address".to_string()))?;
let native_address = native_address(chain);
let wrapped_address = wrapped_address(chain);
if chain != Chain::Ethereum {
if chain.name != *"ethereum" {
return Err(EncodingError::InvalidInput(
"Currently only Ethereum is supported".to_string(),
));
}
Ok(EVMTychoEncoder { strategy_selector, router_address, native_address, wrapped_address })
Ok(EVMTychoEncoder {
strategy_selector,
router_address,
native_address: chain.native_token,
wrapped_address: chain.wrapped_token,
})
}
}
@@ -119,27 +121,38 @@ impl<S: StrategyEncoderRegistry> TychoEncoder<S> for EVMTychoEncoder<S> {
#[cfg(test)]
mod tests {
use tycho_core::dto::{Chain, ProtocolComponent};
use tycho_core::dto::{Chain as TychoCoreChain, ProtocolComponent};
use super::*;
use crate::encoding::{
models::Swap, strategy_encoder::StrategyEncoder, swap_encoder::SwapEncoder,
models::{ChainId, Swap},
strategy_encoder::StrategyEncoder,
swap_encoder::SwapEncoder,
};
struct MockStrategyRegistry {
strategy: Box<dyn StrategyEncoder>,
}
fn eth_chain() -> Chain {
Chain {
id: ChainId(1),
name: TychoCoreChain::Ethereum.to_string(),
native_token: eth(),
wrapped_token: weth(),
}
}
fn dai() -> Bytes {
Bytes::from_str("0x6b175474e89094c44da98b954eedeac495271d0f").unwrap()
}
fn eth() -> Bytes {
native_address(Chain::Ethereum)
Bytes::from_str("0x0000000000000000000000000000000000000000").unwrap()
}
fn weth() -> Bytes {
wrapped_address(Chain::Ethereum)
Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap()
}
impl StrategyEncoderRegistry for MockStrategyRegistry {
@@ -181,11 +194,11 @@ mod tests {
}
fn get_mocked_tycho_encoder() -> EVMTychoEncoder<MockStrategyRegistry> {
let strategy_selector = MockStrategyRegistry::new(Chain::Ethereum, "", None).unwrap();
let strategy_selector = MockStrategyRegistry::new(eth_chain(), "", None).unwrap();
EVMTychoEncoder::new(
strategy_selector,
"0x1234567890abcdef1234567890abcdef12345678".to_string(),
Chain::Ethereum,
eth_chain(),
)
.unwrap()
}

1
src/encoding/mod.rs
View File

@@ -1,3 +1,4 @@
pub mod constants;
mod errors;
#[cfg(feature = "evm")]
pub mod evm;

72
src/encoding/models.rs
View File

@@ -1,5 +1,13 @@
use num_bigint::BigUint;
use tycho_core::{dto::ProtocolComponent, Bytes};
use tycho_core::{
dto::{Chain as TychoCoreChain, ProtocolComponent},
Bytes,
};
use crate::encoding::{
constants::{NATIVE_ADDRESSES, WRAPPED_ADDRESSES},
errors::EncodingError,
};
#[derive(Clone, Default, Debug)]
pub struct Solution {
@@ -68,3 +76,65 @@ pub struct EncodingContext {
pub exact_out: bool,
pub router_address: Bytes,
}
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct ChainId(pub u64);
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct Chain {
pub id: ChainId,
pub name: String,
pub native_token: Bytes,
pub wrapped_token: Bytes,
}
impl ChainId {
pub fn id(&self) -> u64 {
self.0
}
}
impl From<TychoCoreChain> for ChainId {
fn from(chain: TychoCoreChain) -> Self {
match chain {
TychoCoreChain::Ethereum => ChainId(1),
TychoCoreChain::ZkSync => ChainId(324),
TychoCoreChain::Arbitrum => ChainId(42161),
TychoCoreChain::Starknet => ChainId(0),
}
}
}
impl Chain {
pub fn from_tycho_core_chain(
chain: TychoCoreChain,
native_token: Option<Bytes>,
wrapped_token: Option<Bytes>,
) -> Result<Self, EncodingError> {
let native_token_address = match native_token {
Some(token) => token,
None => NATIVE_ADDRESSES.get(&chain)
.cloned()
.ok_or_else(|| EncodingError::InvalidInput(format!(
"Native token does not have a default address for chain {:?}. Please pass the native token address",
chain
)))?,
};
let wrapped_token_address = match wrapped_token {
Some(token) => token,
None => WRAPPED_ADDRESSES.get(&chain)
.cloned()
.ok_or_else(|| EncodingError::InvalidInput(format!(
"Wrapped token does not have a default address for chain {:?}. Please pass the wrapped token address",
chain
)))?,
};
Ok(Chain {
id: chain.into(),
name: chain.to_string(),
native_token: native_token_address,
wrapped_token: wrapped_token_address,
})
}
}

8
src/encoding/strategy_encoder.rs
View File

@@ -1,6 +1,10 @@
use tycho_core::{dto::Chain, Bytes};
use tycho_core::Bytes;
use crate::encoding::{errors::EncodingError, models::Solution, swap_encoder::SwapEncoder};
use crate::encoding::{
errors::EncodingError,
models::{Chain, Solution},
swap_encoder::SwapEncoder,
};
pub trait StrategyEncoder {
fn encode_strategy(