Merge pull request #8 from xdecentralix/erc4626

Erc4626

Author: xdecentralix

Cargo.lock

@@ -0,0 +1,19 @@
+{
+    "abi": [
+      { "type": "function", "name": "asset", "inputs": [], "outputs": [{ "name": "", "type": "address" }], "stateMutability": "view" },
+      { "type": "function", "name": "totalAssets", "inputs": [], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+  
+      { "type": "function", "name": "convertToAssets", "inputs": [{ "name": "shares", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+      { "type": "function", "name": "convertToShares", "inputs": [{ "name": "assets", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+  
+      { "type": "function", "name": "previewDeposit", "inputs": [{ "name": "assets", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+      { "type": "function", "name": "previewMint", "inputs": [{ "name": "shares", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+      { "type": "function", "name": "previewWithdraw", "inputs": [{ "name": "assets", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+      { "type": "function", "name": "previewRedeem", "inputs": [{ "name": "shares", "type": "uint256" }], "outputs": [{ "name": "", "type": "uint256" }], "stateMutability": "view" },
+  
+      { "type": "function", "name": "deposit", "inputs": [{ "name": "assets", "type": "uint256" }, { "name": "receiver", "type": "address" }], "outputs": [{ "name": "shares", "type": "uint256" }], "stateMutability": "nonpayable" },
+      { "type": "function", "name": "mint", "inputs": [{ "name": "shares", "type": "uint256" }, { "name": "receiver", "type": "address" }], "outputs": [{ "name": "assets", "type": "uint256" }], "stateMutability": "nonpayable" },
+      { "type": "function", "name": "withdraw", "inputs": [{ "name": "assets", "type": "uint256" }, { "name": "receiver", "type": "address" }, { "name": "owner", "type": "address" }], "outputs": [{ "name": "shares", "type": "uint256" }], "stateMutability": "nonpayable" },
+      { "type": "function", "name": "redeem", "inputs": [{ "name": "shares", "type": "uint256" }, { "name": "receiver", "type": "address" }, { "name": "owner", "type": "address" }], "outputs": [{ "name": "assets", "type": "uint256" }], "stateMutability": "nonpayable" }
+    ]
+  }

crates/contracts/artifacts/IERC4626.json

@@ -1619,6 +1619,7 @@ fn main() {
             .add_network_str(POLYGON, "0x61fFE014bA17989E743c5F6cB21bF9697530B21e")
         // Not listed on Gnosis and Sepolia chains
     });
+    generate_contract("IERC4626");
     generate_contract_with_config("WETH9", |builder| {
         // Note: the WETH address must be consistent with the one used by the ETH-flow
         // contract

crates/contracts/build.rs

@@ -104,6 +104,7 @@ include_contracts! {
     HooksTrampoline;
     IAavePool;
     IFlashLoanSolverWrapper;
+    IERC4626;
     IRateProvider;
     ISwaprPair;
     IUniswapLikePair;

crates/contracts/src/lib.rs

@@ -0,0 +1,171 @@
+use {
+    crate::{
+        boundary::{self, Result},
+        domain::{eth, liquidity},
+        infra::blockchain::Ethereum,
+    },
+    anyhow::Result as AnyResult,
+    shared::sources::erc4626::registry::Erc4626Registry,
+    solver::{
+        liquidity::erc4626::{Erc4626LiquiditySource, Erc4626Order},
+        liquidity_collector::{BackgroundInitLiquiditySource, LiquidityCollecting},
+    },
+    std::time::Duration,
+};
+
+/// Builds the ERC4626 liquidity collector if enabled via
+/// configs/<chain>/erc4626.toml.
+pub async fn maybe_collector(eth: &Ethereum) -> AnyResult<Vec<Box<dyn LiquidityCollecting>>> {
+    // Try to load per-chain config file; if missing or disabled, return empty.
+    let chain = eth.chain();
+    let chain_str = format!("{:?}", chain);
+    let chain_lc = chain_str.to_lowercase();
+    let primary_path = format!("configs/{}/erc4626.toml", chain_lc);
+    let fallback_path = format!("../{}", primary_path);
+    let web3 = boundary::web3(eth);
+    let settlement = eth.contracts().settlement().clone();
+    let registry: Erc4626Registry = match shared::sources::erc4626::registry::registry_from_file(
+        std::path::Path::new(&primary_path),
+        web3.clone(),
+    ) {
+        Ok(reg) if reg.enabled() => {
+            tracing::debug!(path = %primary_path, "Loaded ERC4626 registry from config file");
+            reg
+        }
+        _ => {
+            // Try fallback path when running from `services/` as CWD
+            match shared::sources::erc4626::registry::registry_from_file(
+                std::path::Path::new(&fallback_path),
+                web3.clone(),
+            ) {
+                Ok(reg) if reg.enabled() => {
+                    tracing::debug!(path = %fallback_path, "Loaded ERC4626 registry from fallback config file");
+                    reg
+                }
+                _ => {
+                    tracing::debug!(
+                        primary = %primary_path,
+                        fallback = %fallback_path,
+                        "ERC4626 registry disabled or config file not found; skipping source"
+                    );
+                    return Ok(vec![]);
+                }
+            }
+        }
+    };
+
+    let source = Erc4626LiquiditySource {
+        web3,
+        settlement,
+        registry,
+    };
+    let init = move || {
+        let source = source.clone();
+        async move {
+            tracing::debug!("initializing ERC4626 liquidity source");
+            Ok(source)
+        }
+    };
+    let collector =
+        BackgroundInitLiquiditySource::new("erc4626", init, Duration::from_secs(5), None);
+    Ok(vec![Box::new(collector)])
+}
+
+pub fn to_domain(id: liquidity::Id, order: Erc4626Order) -> Result<liquidity::Liquidity> {
+    // At this stage, amounts are populated during route realization; here we only
+    // carry tokens and handler wiring
+    let (a, b) = order.tokens.get();
+    Ok(liquidity::Liquidity {
+        id,
+        gas: 90_000u64.into(),
+        kind: liquidity::Kind::Erc4626(liquidity::erc4626::Edge {
+            tokens: (eth::TokenAddress(a.into()), eth::TokenAddress(b.into())),
+        }),
+    })
+}
+
+pub fn to_wrap_interaction(
+    _input: &liquidity::MaxInput,
+    output: &liquidity::ExactOutput,
+    receiver: &eth::Address,
+) -> Result<eth::Interaction> {
+    // encode IERC4626.mint(shares_out, receiver)
+    let selector = hex_literal::hex!("94bf804d"); // mint(uint256,address)
+    let mut shares = [0u8; 32];
+    output.0.amount.0.to_big_endian(&mut shares);
+    // Note: _input is intentionally not used here; it's used for bounded approval
+    // generation elsewhere.
+    tracing::debug!(
+        shares_out = ?output.0.amount.0,
+        receiver = ?receiver.0,
+        target = ?output.0.token.0,
+        "Encoding ERC4626 wrap interaction (mint)"
+    );
+    Ok(eth::Interaction {
+        target: output.0.token.0.into(), // vault address as target
+        value: eth::U256::zero().into(),
+        call_data: [
+            selector.as_slice(),
+            &shares,
+            [0; 12].as_slice(),
+            receiver.0.as_bytes(),
+        ]
+        .concat()
+        .into(),
+    })
+}
+
+pub fn to_unwrap_interaction(
+    _input: &liquidity::MaxInput,
+    output: &liquidity::ExactOutput,
+    receiver: &eth::Address,
+) -> Result<eth::Interaction> {
+    // encode IERC4626.withdraw(assets_out, receiver, owner)
+    let selector = hex_literal::hex!("b460af94"); // withdraw(uint256,address,address)
+    let mut assets = [0u8; 32];
+    output.0.amount.0.to_big_endian(&mut assets);
+    tracing::debug!(
+        assets_out = ?output.0.amount.0,
+        receiver = ?receiver.0,
+        target = ?output.0.token.0,
+        "Encoding ERC4626 unwrap interaction (withdraw)"
+    );
+    Ok(eth::Interaction {
+        target: output.0.token.0.into(), // vault or asset? For withdraw target is vault
+        value: eth::U256::zero().into(),
+        call_data: [
+            selector.as_slice(),
+            &assets,
+            [0; 12].as_slice(),
+            receiver.0.as_bytes(),
+            [0; 12].as_slice(),
+            receiver.0.as_bytes(),
+        ]
+        .concat()
+        .into(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::domain::eth};
+
+    #[test]
+    fn encode_wrap_and_unwrap() {
+        let input = liquidity::MaxInput(eth::Asset {
+            token: eth::H160::zero().into(),
+            amount: 123.into(),
+        });
+        let output = liquidity::ExactOutput(eth::Asset {
+            token: eth::H160::repeat_byte(0x11).into(),
+            amount: 456.into(),
+        });
+        let receiver = &eth::Address(eth::H160::repeat_byte(0x22));
+
+        let wrap = to_wrap_interaction(&input, &output, receiver).unwrap();
+        assert_eq!(&wrap.call_data.0[0..4], &hex_literal::hex!("94bf804d"));
+
+        let unwrap = to_unwrap_interaction(&input, &output, receiver).unwrap();
+        assert_eq!(&unwrap.call_data.0[0..4], &hex_literal::hex!("b460af94"));
+    }
+}

crates/driver/src/boundary/liquidity/erc4626.rs

@@ -27,6 +27,7 @@ use {
 };
 
 pub mod balancer;
+pub mod erc4626;
 pub mod swapr;
 pub mod uniswap;
 pub mod zeroex;
@@ -126,13 +127,24 @@ impl Fetcher {
                 .collect::<Vec<_>>(),
         );
 
+        // Optionally include ERC4626 liquidity source if configured
+        let erc4626_sources = erc4626::maybe_collector(eth).await?;
+
         Ok(Self {
             blocks: block_stream.clone(),
             inner: LiquidityCollector {
-                liquidity_sources: [uni_v2, swapr, bal_v2, bal_v3, uni_v3, zeroex]
-                    .into_iter()
-                    .flatten()
-                    .collect(),
+                liquidity_sources: [
+                    uni_v2,
+                    swapr,
+                    bal_v2,
+                    bal_v3,
+                    uni_v3,
+                    zeroex,
+                    erc4626_sources,
+                ]
+                .into_iter()
+                .flatten()
+                .collect(),
                 base_tokens: Arc::new(base_tokens),
             },
             swapr_routers,
@@ -184,6 +196,7 @@ impl Fetcher {
                     Liquidity::BalancerV3GyroE(pool) => balancer::v3::gyro_e::to_domain(id, pool),
                     Liquidity::LimitOrder(pool) => zeroex::to_domain(id, pool),
                     Liquidity::Concentrated(pool) => uniswap::v3::to_domain(id, pool),
+                    Liquidity::Erc4626(order) => erc4626::to_domain(id, order),
                 }
                 // Ignore "bad" liquidity - this allows the driver to continue
                 // solving with the other good stuff.

crates/driver/src/boundary/liquidity/mod.rs

@@ -182,6 +182,9 @@ pub fn tx(
         prices: auction.native_prices().clone(),
     };
 
+    // NOTE: ERC4626 bounded approvals are emitted via allowances() for Liquidity
+    // interactions or as separate logic if needed.
+
     // Add all interactions needed to move flash loaned tokens around
     // These interactions are executed before all other pre-interactions
     let flashloans = solution
@@ -417,6 +420,29 @@ pub fn liquidity_interaction(
             .swap(&input, &output, &settlement.address().into())
             .ok(),
         liquidity::Kind::ZeroEx(limit_order) => limit_order.to_interaction(&input).ok(),
+        liquidity::Kind::Erc4626(edge) => {
+            // Decide direction by tokens: input.0.token -> output.0.token
+            let (sell, buy) = (input.0.token, output.0.token);
+            if edge.tokens.0 == sell && edge.tokens.1 == buy {
+                // Wrap: mint shares_out to settlement, with bounded approve emitted separately
+                crate::boundary::liquidity::erc4626::to_wrap_interaction(
+                    &input,
+                    &output,
+                    &settlement.address().into(),
+                )
+                .ok()
+            } else if edge.tokens.0 == buy && edge.tokens.1 == sell {
+                // Unwrap: withdraw assets_out to settlement
+                crate::boundary::liquidity::erc4626::to_unwrap_interaction(
+                    &input,
+                    &output,
+                    &settlement.address().into(),
+                )
+                .ok()
+            } else {
+                None
+            }
+        }
     }
     .ok_or(Error::InvalidInteractionExecution(Box::new(
         liquidity.clone(),
@@ -615,4 +641,87 @@ mod test {
             )
         );
     }
+
+    #[test]
+    fn erc4626_wrap_emits_bounded_approval_before_mint() {
+        // Build a minimal solution with a single ERC4626 wrap liquidity interaction
+        use crate::domain::{
+            competition::solution::{
+                Interaction,
+                interaction::Liquidity as InteractionLiquidity,
+                slippage,
+            },
+            eth,
+            liquidity as dl,
+        };
+        let asset = eth::H160::from_low_u64_be(1);
+        let vault = eth::H160::from_low_u64_be(2);
+        let settlement =
+            contracts::dummy_contract!(contracts::GPv2Settlement, eth::H160::from_low_u64_be(3));
+        let liquidity = dl::Liquidity {
+            id: dl::Id(0),
+            gas: eth::Gas(90_000.into()),
+            kind: dl::Kind::Erc4626(dl::erc4626::Edge {
+                tokens: (asset.into(), vault.into()),
+            }),
+        };
+        let liq_interaction = Interaction::Liquidity(InteractionLiquidity {
+            liquidity: liquidity.clone(),
+            input: eth::Asset {
+                token: asset.into(),
+                amount: 100.into(),
+            },
+            output: eth::Asset {
+                token: vault.into(),
+                amount: 95.into(),
+            },
+            internalize: false,
+        });
+
+        // Note: we validate via direct allowances() and interaction selector; no need
+        // to build full Solution here.
+
+        // Encode to interactions list
+        let interaction = liquidity_interaction(
+            &InteractionLiquidity {
+                liquidity: liquidity.clone(),
+                input: eth::Asset {
+                    token: asset.into(),
+                    amount: 100.into(),
+                },
+                output: eth::Asset {
+                    token: vault.into(),
+                    amount: 95.into(),
+                },
+                internalize: false,
+            },
+            &slippage::Parameters {
+                relative: num::rational::Ratio::from_integer(0.into()),
+                max: None,
+                min: None,
+                prices: Default::default(),
+            },
+            &settlement,
+        )
+        .unwrap();
+
+        // Ensure allowance requires bounded amount
+        let allowances = Interaction::Liquidity(InteractionLiquidity {
+            liquidity,
+            input: eth::Asset {
+                token: asset.into(),
+                amount: 100.into(),
+            },
+            output: eth::Asset {
+                token: vault.into(),
+                amount: 95.into(),
+            },
+            internalize: false,
+        })
+        .allowances();
+        assert_eq!(allowances.len(), 1);
+        assert_eq!(allowances[0].0.amount, 100.into());
+        // Ensure interaction is a mint (selector 0x94bf804d)
+        assert_eq!(&interaction.call_data.0[0..4], &hex!("94bf804d"));
+    }
 }