Yo yielder integration

Cargo.toml

@@ -53,6 +53,7 @@ members = [
     "crates/tracing",
     "crates/claude",
     "crates/support",
+    "crates/yielder",
 ]
 
 [workspace.dependencies]

crates/gem_evm/src/contracts/erc4626.rs

@@ -0,0 +1,9 @@
+use alloy_sol_types::sol;
+
+sol! {
+    interface IERC4626 {
+        function balanceOf(address account) external view returns (uint256);
+        function totalAssets() external view returns (uint256);
+        function totalSupply() external view returns (uint256);
+    }
+}

crates/gem_evm/src/contracts/mod.rs

@@ -1,7 +1,9 @@
-pub mod erc1155;
 pub mod erc20;
 pub mod erc721;
+pub mod erc1155;
+pub mod erc4626;
 
 pub use erc20::IERC20;
 pub use erc721::IERC721;
 pub use erc1155::IERC1155;
+pub use erc4626::IERC4626;

crates/gem_evm/src/lib.rs

@@ -17,6 +17,7 @@ pub mod jsonrpc;
 pub mod message;
 pub mod monad;
 pub mod multicall3;
+pub mod slippage;
 pub mod permit2;
 #[cfg(feature = "rpc")]
 pub mod registry;

crates/gem_evm/src/rpc/client.rs

@@ -277,4 +277,25 @@ impl<C: Client + Clone> EthereumClient<C> {
 
         Ok(multicall_results)
     }
+
+    #[cfg(feature = "rpc")]
+    pub async fn call_contract<T: SolCall>(&self, target: Address, sol_call: T) -> Result<T::Return, Box<dyn std::error::Error + Sync + Send>> {
+        let call_data = hex::encode_prefixed(sol_call.abi_encode());
+        let params = json!([{ "to": target.to_string(), "data": call_data }, Self::latest_block_parameter()]);
+        let result: String = self.client.call("eth_call", params).await?;
+        let result_data = hex::decode(&result)?;
+        Ok(T::abi_decode_returns(&result_data)?)
+    }
+
+    #[cfg(feature = "rpc")]
+    pub async fn multicall3_map<T, R, const N: usize>(
+        &self,
+        items: &[T],
+        build: impl Fn(&T) -> [Call3; N],
+        decode: impl Fn(&[MulticallResult]) -> Result<R, Box<dyn std::error::Error + Send + Sync>>,
+    ) -> Result<Vec<R>, Box<dyn std::error::Error + Sync + Send>> {
+        let calls = items.iter().flat_map(&build).collect();
+        let results = self.multicall3(calls).await?;
+        results.chunks(N).map(&decode).collect()
+    }
 }

crates/swapper/src/slippage.rs → crates/gem_evm/src/slippage.rs

@@ -39,7 +39,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_apply_slippage() {
+    fn test_apply_slippage_in_bp() {
         assert_eq!(apply_slippage_in_bp(&U256::from(100), 300), U256::from(97));
         assert_eq!(apply_slippage_in_bp(&100_u128, 300), 97_u128);
         assert_eq!(apply_slippage_in_bp(&1000_u64, 500), 950_u64);

crates/swapper/src/alien/error.rs → crates/gem_jsonrpc/src/alien.rs

@@ -1,5 +1,10 @@
+use std::sync::Arc;
+
 use gem_client::ClientError;
-use gem_jsonrpc::RpcClientError;
+use primitives::Chain;
+
+use crate::client::JsonRpcClient;
+use crate::rpc::{RpcClient as GenericRpcClient, RpcClientError, RpcProvider as GenericRpcProvider};
 
 #[derive(Debug, Clone)]
 pub enum AlienError {
@@ -28,9 +33,9 @@ impl AlienError {
 impl std::fmt::Display for AlienError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::RequestError { msg } => write!(f, "Request error: {}", msg),
-            Self::ResponseError { msg } => write!(f, "Response error: {}", msg),
-            Self::Http { status, .. } => write!(f, "HTTP error: status {}", status),
+            Self::RequestError { msg } => write!(f, "Request error: {msg}"),
+            Self::ResponseError { msg } => write!(f, "Response error: {msg}"),
+            Self::Http { status, .. } => write!(f, "HTTP error: status {status}"),
         }
     }
 }
@@ -40,9 +45,20 @@ impl std::error::Error for AlienError {}
 impl RpcClientError for AlienError {
     fn into_client_error(self) -> ClientError {
         match self {
-            Self::RequestError { msg } => ClientError::Network(msg),
-            Self::ResponseError { msg } => ClientError::Network(msg),
+            Self::RequestError { msg } | Self::ResponseError { msg } => ClientError::Network(msg),
             Self::Http { status, .. } => ClientError::Http { status, body: Vec::new() },
         }
     }
 }
+
+pub type RpcClient = GenericRpcClient<AlienError>;
+
+pub trait RpcProvider: GenericRpcProvider<Error = AlienError> {}
+
+impl<T> RpcProvider for T where T: GenericRpcProvider<Error = AlienError> {}
+
+pub fn create_client(provider: Arc<dyn RpcProvider>, chain: Chain) -> Result<JsonRpcClient<RpcClient>, AlienError> {
+    let endpoint = provider.get_endpoint(chain)?;
+    let client = RpcClient::new(endpoint, provider);
+    Ok(JsonRpcClient::new(client))
+}

crates/gem_jsonrpc/src/lib.rs

@@ -1,5 +1,7 @@
 pub mod types;
 
+#[cfg(feature = "client")]
+pub mod alien;
 #[cfg(feature = "client")]
 pub mod client;
 #[cfg(feature = "client")]

crates/primitives/src/earn_type.rs

@@ -10,3 +10,16 @@ pub enum EarnType {
     Deposit(DelegationValidator),
     Withdraw(Delegation),
 }
+
+impl EarnType {
+    pub fn provider(&self) -> &DelegationValidator {
+        match self {
+            EarnType::Deposit(provider) => provider,
+            EarnType::Withdraw(delegation) => &delegation.validator,
+        }
+    }
+
+    pub fn provider_id(&self) -> &str {
+        &self.provider().id
+    }
+}

crates/primitives/src/yield_provider.rs

@@ -9,3 +9,11 @@ use typeshare::typeshare;
 pub enum YieldProvider {
     Yo,
 }
+
+impl YieldProvider {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Yo => "Yo",
+        }
+    }
+}

crates/swapper/src/alien/mock.rs

@@ -5,7 +5,8 @@ use std::{
 };
 
 use super::{AlienError, Target};
-use gem_jsonrpc::{RpcProvider as GenericRpcProvider, RpcResponse};
+use gem_jsonrpc::RpcResponse;
+use gem_jsonrpc::rpc::RpcProvider as GenericRpcProvider;
 use primitives::Chain;
 
 #[allow(unused)]

crates/swapper/src/alien/mod.rs

@@ -1,13 +1,6 @@
-pub mod error;
 pub mod mock;
 #[cfg(feature = "reqwest_provider")]
 pub mod reqwest_provider;
 
-pub use error::AlienError;
-pub use gem_jsonrpc::{HttpMethod, RpcClient as GenericRpcClient, RpcProvider as GenericRpcProvider, Target};
-
-pub type RpcClient = GenericRpcClient<AlienError>;
-
-pub trait RpcProvider: GenericRpcProvider<Error = AlienError> {}
-
-impl<T> RpcProvider for T where T: GenericRpcProvider<Error = AlienError> {}
+pub use gem_jsonrpc::alien::{AlienError, RpcClient, RpcProvider};
+pub use gem_jsonrpc::{HttpMethod, Target};

crates/swapper/src/alien/reqwest_provider.rs

@@ -5,7 +5,8 @@ use primitives::{Chain, node_config::get_nodes_for_chain};
 
 use async_trait::async_trait;
 use futures::TryFutureExt;
-use gem_jsonrpc::{RpcProvider as GenericRpcProvider, RpcResponse};
+use gem_jsonrpc::RpcResponse;
+use gem_jsonrpc::rpc::RpcProvider as GenericRpcProvider;
 use reqwest::Client;
 
 #[derive(Debug)]

crates/swapper/src/chainflip/provider.rs

@@ -14,9 +14,11 @@ use super::{
     seed::generate_random_seed,
     tx_builder,
 };
+use gem_evm::slippage::apply_slippage_in_bp;
+
 use crate::{
     FetchQuoteData, ProviderData, ProviderType, Quote, QuoteRequest, Route, SwapResult, Swapper, SwapperChainAsset, SwapperError, SwapperProvider, SwapperQuoteData,
-    alien::RpcProvider, amount_to_value, approval::check_approval_erc20, config::DEFAULT_CHAINFLIP_FEE_BPS, cross_chain::VaultAddresses, slippage,
+    alien::RpcProvider, amount_to_value, approval::check_approval_erc20, config::DEFAULT_CHAINFLIP_FEE_BPS, cross_chain::VaultAddresses,
 };
 use primitives::{ChainType, chain::Chain, swap::QuoteAsset};
 
@@ -218,7 +220,7 @@ where
             })
         } else if from_asset.chain.chain_type() == ChainType::Bitcoin {
             let output_amount: U256 = quote.to_value.parse()?;
-            let min_output_amount = slippage::apply_slippage_in_bp(&output_amount, quote.data.slippage_bps);
+            let min_output_amount = apply_slippage_in_bp(&output_amount, quote.data.slippage_bps);
             VaultSwapExtras::Bitcoin(VaultSwapBtcExtras {
                 chain,
                 min_output_amount: BigUint::from_bytes_le(&min_output_amount.to_le_bytes::<32>()),

crates/swapper/src/client_factory.rs

@@ -1,22 +1,18 @@
 use gem_evm::rpc::EthereumClient;
+use gem_jsonrpc::alien::{self, RpcClient, RpcProvider};
 use gem_jsonrpc::client::JsonRpcClient;
 use primitives::{Chain, EVMChain};
 use std::sync::Arc;
 
-use crate::{
-    SwapperError,
-    alien::{RpcClient, RpcProvider},
-};
+use crate::SwapperError;
 
 pub fn create_client_with_chain(provider: Arc<dyn RpcProvider>, chain: Chain) -> JsonRpcClient<RpcClient> {
-    let endpoint = provider.get_endpoint(chain).expect("Failed to get endpoint for chain");
-    let client = RpcClient::new(endpoint, provider);
-    JsonRpcClient::new(client)
+    alien::create_client(provider, chain).expect("failed to create client for chain")
 }
 
 pub fn create_eth_client(provider: Arc<dyn RpcProvider>, chain: Chain) -> Result<EthereumClient<RpcClient>, SwapperError> {
     let evm_chain = EVMChain::from_chain(chain).ok_or(SwapperError::NotSupportedChain)?;
-    let client = create_client_with_chain(provider, chain);
+    let client = alien::create_client(provider, chain).map_err(|_| SwapperError::NotSupportedChain)?;
     Ok(EthereumClient::new(client, evm_chain))
 }
 

crates/swapper/src/lib.rs

@@ -23,7 +23,6 @@ pub mod permit2_data;
 pub mod proxy;
 pub mod referrer;
 pub mod relay;
-pub mod slippage;
 pub mod swapper;
 pub mod thorchain;
 pub mod uniswap;

crates/swapper/src/uniswap/v3/commands.rs

@@ -1,4 +1,5 @@
-use crate::{SwapperError, SwapperMode, eth_address, models::*, slippage::apply_slippage_in_bp};
+use crate::{SwapperError, SwapperMode, eth_address, models::*};
+use gem_evm::slippage::apply_slippage_in_bp;
 use gem_evm::uniswap::command::{ADDRESS_THIS, PayPortion, Permit2Permit, Sweep, Transfer, UniversalRouterCommand, UnwrapWeth, V3SwapExactIn, WrapEth};
 
 use alloy_primitives::{Address, Bytes, U256};

crates/swapper/src/uniswap/v3/provider.rs

@@ -1,10 +1,11 @@
+use gem_evm::slippage::apply_slippage_in_bp;
+
 use crate::{
     FetchQuoteData, Permit2ApprovalData, ProviderData, ProviderType, Quote, QuoteRequest, Swapper, SwapperError, SwapperQuoteData,
     alien::{RpcClient, RpcProvider},
     approval::{check_approval_erc20_with_client, check_approval_permit2_with_client},
     eth_address,
     models::*,
-    slippage::apply_slippage_in_bp,
     uniswap::{
         deadline::get_sig_deadline,
         fee_token::get_fee_token,

crates/swapper/src/uniswap/v4/commands.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
-use crate::{QuoteRequest, Route, SwapperError, SwapperMode, eth_address, slippage::apply_slippage_in_bp};
+use crate::{QuoteRequest, Route, SwapperError, SwapperMode, eth_address};
+use gem_evm::slippage::apply_slippage_in_bp;
 use alloy_primitives::{Address, U256};
 use gem_evm::uniswap::{
     actions::V4Action::{SETTLE, SWAP_EXACT_IN, TAKE},

crates/swapper/src/uniswap/v4/provider.rs

@@ -2,12 +2,13 @@ use alloy_primitives::{Address, U256, hex::encode_prefixed as HexEncode};
 use async_trait::async_trait;
 use std::{collections::HashSet, fmt, str::FromStr, sync::Arc, vec};
 
+use gem_evm::slippage::apply_slippage_in_bp;
+
 use crate::{
     FetchQuoteData, Permit2ApprovalData, ProviderData, ProviderType, Quote, QuoteRequest, Swapper, SwapperChainAsset, SwapperError, SwapperProvider, SwapperQuoteData,
     alien::{RpcClient, RpcProvider},
     approval::evm::{check_approval_erc20_with_client, check_approval_permit2_with_client},
     eth_address,
-    slippage::apply_slippage_in_bp,
     uniswap::{
         deadline::get_sig_deadline,
         fee_token::get_fee_token,

crates/yielder/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "yielder"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[features]
+default = []
+yield_integration_tests = [
+    "gem_jsonrpc/reqwest",
+    "gem_client/reqwest",
+    "tokio/rt-multi-thread",
+]
+
+[dependencies]
+alloy-primitives = { workspace = true }
+alloy-sol-types = { workspace = true }
+num-bigint = { workspace = true }
+gem_client = { path = "../gem_client" }
+gem_evm = { path = "../gem_evm", features = ["rpc"] }
+gem_jsonrpc = { path = "../gem_jsonrpc" }
+primitives = { path = "../primitives" }
+async-trait = { workspace = true }
+futures = { workspace = true }
+
+[dev-dependencies]
+gem_client = { path = "../gem_client", features = ["reqwest"] }
+gem_jsonrpc = { path = "../gem_jsonrpc", features = ["reqwest"] }
+reqwest = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

crates/yielder/src/client_factory.rs

@@ -0,0 +1,17 @@
+use gem_evm::rpc::EthereumClient;
+use gem_jsonrpc::alien::{self, RpcClient, RpcProvider};
+use gem_jsonrpc::client::JsonRpcClient;
+use primitives::{Chain, EVMChain};
+use std::sync::Arc;
+
+use crate::YielderError;
+
+pub fn create_client(provider: Arc<dyn RpcProvider>, chain: Chain) -> Result<JsonRpcClient<RpcClient>, YielderError> {
+    alien::create_client(provider, chain).map_err(|_| YielderError::NotSupportedChain)
+}
+
+pub fn create_eth_client(provider: Arc<dyn RpcProvider>, chain: Chain) -> Result<EthereumClient<RpcClient>, YielderError> {
+    let evm_chain = EVMChain::from_chain(chain).ok_or(YielderError::NotSupportedChain)?;
+    let client = create_client(provider, chain)?;
+    Ok(EthereumClient::new(client, evm_chain))
+}