Add Yielder crate

Cargo.toml

@@ -47,6 +47,7 @@ members = [
     "crates/streamer",
     "crates/swapper",
     "crates/tracing",
+    "crates/yielder",
 ]
 
 [workspace.dependencies]

apps/api/src/nft/mod.rs

@@ -81,7 +81,12 @@ pub async fn report_nft(request: Json<ReportNft>, client: &State<Mutex<NFTClient
     Ok(client
         .lock()
         .await
-        .report_nft(&request.device_id, request.collection_id.clone(), request.asset_id.clone(), request.reason.clone())?
+        .report_nft(
+            &request.device_id,
+            request.collection_id.clone(),
+            request.asset_id.clone(),
+            request.reason.clone(),
+        )?
         .into())
 }
 

crates/nft/src/client.rs

@@ -198,7 +198,13 @@ impl NFTClient {
         self.preload(asset_ids.clone()).await
     }
 
-    pub fn report_nft(&self, device_id: &str, collection_id: String, asset_id: Option<String>, reason: Option<String>) -> Result<bool, Box<dyn Error + Send + Sync>> {
+    pub fn report_nft(
+        &self,
+        device_id: &str,
+        collection_id: String,
+        asset_id: Option<String>,
+        reason: Option<String>,
+    ) -> Result<bool, Box<dyn Error + Send + Sync>> {
         let device = self.database.client()?.get_device(device_id)?;
         let report = storage::models::NewNftReport {
             device_id: device.id,

crates/storage/src/repositories/nft_repository.rs

@@ -2,7 +2,10 @@ use crate::DatabaseError;
 
 use crate::DatabaseClient;
 use crate::database::nft::NftStore;
-use crate::models::{NftAsset, NftCollection, NftType, nft_asset::UpdateNftAssetImageUrl, nft_collection::UpdateNftCollectionImageUrl, nft_link::NftLink, nft_report::NewNftReport};
+use crate::models::{
+    NftAsset, NftCollection, NftType, nft_asset::UpdateNftAssetImageUrl, nft_collection::UpdateNftCollectionImageUrl, nft_link::NftLink,
+    nft_report::NewNftReport,
+};
 
 pub trait NftRepository {
     fn get_nft_assets(&mut self, asset_ids: Vec<String>) -> Result<Vec<NftAsset>, DatabaseError>;

crates/yielder/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "yielder"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+description.workspace = true
+repository.workspace = true
+documentation.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 }
+gem_client = { path = "../gem_client" }
+gem_evm = { path = "../gem_evm", features = ["rpc"] }
+primitives = { path = "../primitives" }
+async-trait = { workspace = true }
+num-traits = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["macros"] }
+
+[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/lib.rs

@@ -0,0 +1,8 @@
+mod provider;
+pub mod yo;
+
+pub use provider::{Yield, YieldDetailsRequest, YieldPosition, YieldProvider, YieldProviderClient, YieldTransaction, Yielder};
+pub use yo::{IYoGateway, YO_GATEWAY_BASE_MAINNET, YO_PARTNER_ID_GEM, YO_USD, YieldError, YoGatewayClient, YoProvider, YoVault, YoYieldProvider, vaults};
+
+#[cfg(all(test, feature = "yield_integration_tests"))]
+mod yield_integration_tests;

crates/yielder/src/provider.rs

@@ -0,0 +1,172 @@
+use std::{fmt, str::FromStr, sync::Arc};
+
+use alloy_primitives::Address;
+use async_trait::async_trait;
+use primitives::{AssetId, Chain};
+
+use crate::yo::YieldError;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum YieldProvider {
+    Yo,
+}
+
+impl YieldProvider {
+    pub fn name(&self) -> &'static str {
+        match self {
+            YieldProvider::Yo => "yo",
+        }
+    }
+}
+
+impl fmt::Display for YieldProvider {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.name())
+    }
+}
+
+impl FromStr for YieldProvider {
+    type Err = YieldError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value.to_ascii_lowercase().as_str() {
+            "yo" => Ok(YieldProvider::Yo),
+            other => Err(YieldError::new(format!("unknown yield provider {other}"))),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Yield {
+    pub name: String,
+    pub asset_id: AssetId,
+    pub provider: YieldProvider,
+    pub apy: Option<f64>,
+}
+
+impl Yield {
+    pub fn new(name: impl Into<String>, asset_id: AssetId, provider: YieldProvider, apy: Option<f64>) -> Self {
+        Self {
+            name: name.into(),
+            asset_id,
+            provider,
+            apy,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct YieldTransaction {
+    pub chain: Chain,
+    pub from: String,
+    pub to: String,
+    pub data: String,
+    pub value: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct YieldDetailsRequest {
+    pub asset_id: AssetId,
+    pub wallet_address: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct YieldPosition {
+    pub asset_id: AssetId,
+    pub provider: YieldProvider,
+    pub vault_token_address: String,
+    pub asset_token_address: String,
+    pub vault_balance_value: Option<String>,
+    pub asset_balance_value: Option<String>,
+    pub apy: Option<f64>,
+    pub rewards: Option<String>,
+}
+
+impl YieldPosition {
+    pub fn new(asset_id: AssetId, provider: YieldProvider, share_token: Address, asset_token: Address) -> Self {
+        Self {
+            asset_id,
+            provider,
+            vault_token_address: share_token.to_string(),
+            asset_token_address: asset_token.to_string(),
+            vault_balance_value: None,
+            asset_balance_value: None,
+            apy: None,
+            rewards: None,
+        }
+    }
+}
+
+#[async_trait]
+pub trait YieldProviderClient: Send + Sync {
+    fn provider(&self) -> YieldProvider;
+    fn yields(&self, asset_id: &AssetId) -> Vec<Yield>;
+    async fn deposit(&self, asset_id: &AssetId, wallet_address: &str, value: &str) -> Result<YieldTransaction, YieldError>;
+    async fn withdraw(&self, asset_id: &AssetId, wallet_address: &str, value: &str) -> Result<YieldTransaction, YieldError>;
+    async fn positions(&self, request: &YieldDetailsRequest) -> Result<YieldPosition, YieldError>;
+    async fn yields_with_apy(&self, asset_id: &AssetId) -> Result<Vec<Yield>, YieldError> {
+        Ok(self.yields(asset_id))
+    }
+}
+
+#[derive(Default)]
+pub struct Yielder {
+    providers: Vec<Arc<dyn YieldProviderClient>>,
+}
+
+impl Yielder {
+    pub fn new() -> Self {
+        Self { providers: Vec::new() }
+    }
+
+    pub fn with_providers(providers: Vec<Arc<dyn YieldProviderClient>>) -> Self {
+        Self { providers }
+    }
+
+    pub fn add_provider<P>(&mut self, provider: P)
+    where
+        P: YieldProviderClient + 'static,
+    {
+        self.providers.push(Arc::new(provider));
+    }
+
+    pub fn add_provider_arc(&mut self, provider: Arc<dyn YieldProviderClient>) {
+        self.providers.push(provider);
+    }
+
+    pub fn yields_for_asset(&self, asset_id: &AssetId) -> Vec<Yield> {
+        self.providers.iter().flat_map(|provider| provider.yields(asset_id)).collect()
+    }
+
+    pub async fn yields_for_asset_with_apy(&self, asset_id: &AssetId) -> Result<Vec<Yield>, YieldError> {
+        let mut yields = Vec::new();
+        for provider in &self.providers {
+            let mut provider_yields = provider.yields_with_apy(asset_id).await?;
+            yields.append(&mut provider_yields);
+        }
+        Ok(yields)
+    }
+
+    pub async fn deposit(&self, provider: YieldProvider, asset_id: &AssetId, wallet_address: &str, value: &str) -> Result<YieldTransaction, YieldError> {
+        let provider = self.provider(provider)?;
+        provider.deposit(asset_id, wallet_address, value).await
+    }
+
+    pub async fn withdraw(&self, provider: YieldProvider, asset_id: &AssetId, wallet_address: &str, value: &str) -> Result<YieldTransaction, YieldError> {
+        let provider = self.provider(provider)?;
+        provider.withdraw(asset_id, wallet_address, value).await
+    }
+
+    pub async fn positions(&self, provider: YieldProvider, request: &YieldDetailsRequest) -> Result<YieldPosition, YieldError> {
+        let provider = self.provider(provider)?;
+        provider.positions(request).await
+    }
+
+    fn provider(&self, provider: YieldProvider) -> Result<Arc<dyn YieldProviderClient>, YieldError> {
+        self.providers
+            .iter()
+            .find(|candidate| candidate.provider() == provider)
+            .cloned()
+            .ok_or_else(|| YieldError::new(format!("provider {provider} not found")))
+    }
+}

crates/yielder/src/yield_integration_tests.rs

@@ -0,0 +1,39 @@
+#![cfg(all(test, feature = "yield_integration_tests"))]
+
+use std::sync::Arc;
+
+use gem_evm::rpc::EthereumClient;
+use gem_jsonrpc::client::JsonRpcClient;
+use primitives::EVMChain;
+
+use crate::{YO_GATEWAY_BASE_MAINNET, YO_USD, YieldDetailsRequest, YieldProvider, YieldProviderClient, Yielder, YoGatewayClient, YoYieldProvider};
+
+#[tokio::test]
+async fn yield_integration_test_fetches_performance_apy() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let rpc_url = std::env::var("BASE_RPC_URL").unwrap_or_else(|_| "https://mainnet.base.org".to_string());
+    let jsonrpc_client = JsonRpcClient::new_reqwest(rpc_url);
+    let ethereum_client = EthereumClient::new(jsonrpc_client, EVMChain::Base);
+    let gateway_client = YoGatewayClient::new(ethereum_client, YO_GATEWAY_BASE_MAINNET);
+    let provider: Arc<dyn YieldProviderClient> = Arc::new(YoYieldProvider::new(Arc::new(gateway_client)));
+    let yielder = Yielder::with_providers(vec![provider]);
+
+    let apy_yields = yielder.yields_for_asset_with_apy(&YO_USD.asset_id()).await?;
+    assert!(!apy_yields.is_empty(), "expected at least one Yo vault for asset");
+    let apy = apy_yields[0].apy.expect("apy should be computed");
+    assert!(apy.is_finite(), "apy should be finite");
+    assert!(apy > -1.0, "apy should be > -100%");
+
+    let details = yielder
+        .positions(
+            YieldProvider::Yo,
+            &YieldDetailsRequest {
+                asset_id: YO_USD.asset_id(),
+                wallet_address: "0x0000000000000000000000000000000000000000".to_string(),
+            },
+        )
+        .await?;
+
+    assert!(details.apy.is_some(), "apy should be present in details");
+
+    Ok(())
+}