feat: generalized wrappers

configs/local/driver.toml

@@ -1,3 +1,5 @@
+app-data-fetching-enabled = true
+orderbook-url = "http://orderbook"
 tx-gas-limit = "45000000"
 
 [[solver]]

crates/app-data/src/app_data.rs

@@ -1,6 +1,7 @@
 use {
     crate::{AppDataHash, Hooks, app_data_hash::hash_full_app_data},
     anyhow::{Context, Result, anyhow},
+    bytes_hex::BytesHex,
     number::serialization::HexOrDecimalU256,
     primitive_types::{H160, U256},
     serde::{Deserialize, Deserializer, Serialize, Serializer, de},
@@ -21,6 +22,7 @@ pub struct ValidatedAppData {
     pub protocol: ProtocolAppData,
 }
 
+#[serde_as]
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 #[cfg_attr(any(test, feature = "test_helpers"), derive(Serialize))]
 #[serde(rename_all = "camelCase")]
@@ -32,6 +34,8 @@ pub struct ProtocolAppData {
     #[serde(default)]
     pub partner_fee: PartnerFees,
     pub flashloan: Option<Flashloan>,
+    #[serde(default)]
+    pub wrappers: Vec<WrapperCall>,
 }
 
 /// Contains information to hint at how a solver could make
@@ -57,6 +61,23 @@ pub struct Flashloan {
     pub amount: U256,
 }
 
+/// Contains information about wrapper contracts
+#[serde_as]
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[cfg_attr(any(test, feature = "test_helpers"), derive(Serialize))]
+#[serde(rename_all = "camelCase")]
+pub struct WrapperCall {
+    /// The address of the wrapper contract.
+    pub address: H160,
+    /// Additional calldata to be passed to the wrapper contract.
+    #[serde_as(as = "BytesHex")]
+    pub data: Vec<u8>,
+    /// Declares whether this wrapper (and its data) needs to be included
+    /// unmodified in a solution containing this order.
+    #[serde(default)]
+    pub is_omittable: bool,
+}
+
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 #[cfg_attr(any(test, feature = "test_helpers"), derive(Serialize))]
 pub struct ReplacedOrder {
@@ -440,6 +461,7 @@ impl From<BackendAppData> for ProtocolAppData {
     fn from(value: BackendAppData) -> Self {
         Self {
             hooks: value.hooks,
+            wrappers: Vec::new(),
             signer: None,
             replaced_order: None,
             partner_fee: PartnerFees::default(),

crates/contracts/artifacts/ICowWrapper.json

@@ -0,0 +1,41 @@
+{
+  "abi": [
+    {
+      "type": "function",
+      "name": "parseWrapperData",
+      "inputs": [
+        {
+          "name": "wrapperData",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "remainingWrapperData",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "function",
+      "name": "wrappedSettle",
+      "inputs": [
+        {
+          "name": "settleData",
+          "type": "bytes",
+          "internalType": "bytes"
+        },
+        {
+          "name": "wrapperData",
+          "type": "bytes",
+          "internalType": "bytes"
+        }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    }
+  ]
+}

crates/contracts/src/alloy.rs

@@ -615,6 +615,8 @@ crate::bindings!(
     }
 );
 
+crate::bindings!(ICowWrapper);
+
 // Only used in <github.com/gnosis/solvers>
 crate::bindings!(
     Permit2,

crates/driver/src/domain/competition/order/app_data.rs

@@ -126,6 +126,13 @@ impl AppData {
             Self::Full(data) => data.protocol.flashloan.as_ref(),
         }
     }
+
+    pub fn wrappers(&self) -> &[app_data::WrapperCall] {
+        match self {
+            Self::Hash(_) => &[],
+            Self::Full(data) => &data.protocol.wrappers,
+        }
+    }
 }
 
 impl From<[u8; APP_DATA_LEN]> for AppData {

crates/driver/src/domain/competition/solution/encoding.rs

@@ -13,6 +13,7 @@ use {
         util::Bytes,
     },
     allowance::Allowance,
+    alloy::sol_types::SolCall,
     contracts::alloy::{FlashLoanRouter::LoanRequest, WETH9},
     ethcontract::H160,
     ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
@@ -32,6 +33,8 @@ pub enum Error {
     // TODO: remove when contracts are deployed everywhere
     #[error("flashloan support disabled")]
     FlashloanSupportDisabled,
+    #[error("both wrappers and flashloans cannot be encoded in the same auction")]
+    FlashloanWrappersIncompatible,
 }
 
 pub fn tx(
@@ -206,6 +209,10 @@ pub fn tx(
         interactions.push(unwrap(native_unwrap, contracts.weth()));
     }
 
+    let has_flashloans = !solution.flashloans.is_empty();
+    let has_wrappers = !solution.wrappers.is_empty();
+
+    // Encode the base settlement calldata
     let mut settle_calldata = contracts
         .settlement()
         .settle(
@@ -221,36 +228,20 @@ pub fn tx(
         .calldata()
         .to_vec();
 
-    // Encode the auction id into the calldata
+    // Append auction ID to settlement calldata
     settle_calldata.extend(auction.id().ok_or(Error::MissingAuctionId)?.to_be_bytes());
 
-    // Target and calldata depend on whether a flashloan is used
-    let (to, calldata) = if solution.flashloans.is_empty() {
+    let (to, calldata) = if has_flashloans && has_wrappers {
+        return Err(Error::FlashloanWrappersIncompatible);
+    } else if has_flashloans {
+        encode_flashloan_settlement(solution, contracts, settle_calldata)?
+    } else if has_wrappers {
+        encode_wrapper_settlement(solution, settle_calldata)
+    } else {
         (
             contracts.settlement().address().into_legacy().into(),
             settle_calldata,
         )
-    } else {
-        let router = contracts
-            .flashloan_router()
-            .ok_or(Error::FlashloanSupportDisabled)?;
-
-        let flashloans = solution
-            .flashloans
-            .values()
-            .map(|flashloan| LoanRequest::Data {
-                amount: flashloan.amount.0.into_alloy(),
-                borrower: flashloan.protocol_adapter.0.into_alloy(),
-                lender: flashloan.liquidity_provider.0.into_alloy(),
-                token: flashloan.token.0.0.into_alloy(),
-            })
-            .collect();
-
-        let calldata = router
-            .flashLoanAndSettle(flashloans, settle_calldata.into())
-            .calldata()
-            .to_vec();
-        (router.address().into_legacy().into(), calldata)
     };
 
     Ok(eth::Tx {
@@ -262,6 +253,95 @@ pub fn tx(
     })
 }
 
+/// Encodes a settlement transaction that uses flashloans.
+///
+/// Takes the base settlement calldata and wraps it in a flashLoanAndSettle call
+/// to the flashloan router contract.
+///
+/// Returns (router_address, flashloan_calldata)
+fn encode_flashloan_settlement(
+    solution: &super::Solution,
+    contracts: &infra::blockchain::Contracts,
+    settle_calldata: Vec<u8>,
+) -> Result<(eth::Address, Vec<u8>), Error> {
+    // Get flashloan router contract
+    let router = contracts
+        .flashloan_router()
+        .ok_or(Error::FlashloanSupportDisabled)?;
+
+    // Convert flashloans to LoanRequest format
+    let flashloans = solution
+        .flashloans
+        .values()
+        .map(|flashloan| LoanRequest::Data {
+            amount: flashloan.amount.0.into_alloy(),
+            borrower: flashloan.protocol_adapter.0.into_alloy(),
+            lender: flashloan.liquidity_provider.0.into_alloy(),
+            token: flashloan.token.0.0.into_alloy(),
+        })
+        .collect();
+
+    // Wrap settlement in flashLoanAndSettle call
+    let calldata = router
+        .flashLoanAndSettle(flashloans, settle_calldata.into())
+        .calldata()
+        .to_vec();
+
+    Ok((router.address().into_legacy().into(), calldata))
+}
+
+/// Encodes a settlement transaction that uses wrapper contracts.
+///
+/// Takes the base settlement calldata and wraps it in a wrappedSettleCall
+/// with encoded wrapper metadata. Since wrappers are a chain, the wrapper
+/// address to call is also processed by this function.
+///
+/// Returns (first_wrapper_address, wrapped_calldata)
+fn encode_wrapper_settlement(
+    solution: &super::Solution,
+    settle_calldata: Vec<u8>,
+) -> (eth::Address, Vec<u8>) {
+    // Encode wrapper metadata
+    let wrapper_data = encode_wrapper_data(&solution.wrappers);
+
+    // Create wrappedSettleCall
+    let calldata = contracts::alloy::ICowWrapper::ICowWrapper::wrappedSettleCall {
+        settleData: settle_calldata.into(),
+        wrapperData: wrapper_data.into(),
+    }
+    .abi_encode();
+
+    (solution.wrappers[0].address, calldata)
+}
+
+/// Encodes wrapper metadata for wrapper settlement calls.
+///
+/// The format is:
+/// - For wrappers after the first: 20 bytes (address)
+/// - For each wrapper: 2 bytes (data length as u16 in native endian) + data
+///
+/// More information about wrapper encoding:
+/// https://www.notion.so/cownation/Generalized-Wrapper-2798da5f04ca8095a2d4c56b9d17134e?source=copy_link#2858da5f04ca807980bbf7f845354120
+///
+/// Note: The first wrapper address is omitted from the encoded data since it's
+/// already used as the transaction target.
+fn encode_wrapper_data(wrappers: &[super::WrapperCall]) -> Vec<u8> {
+    let mut wrapper_data = Vec::new();
+
+    for (index, w) in wrappers.iter().enumerate() {
+        // Skip first wrapper's address (it's the transaction target)
+        if index != 0 {
+            wrapper_data.extend(w.address.0.as_bytes());
+        }
+
+        // Encode data length as u16 in native endian, then the data itself
+        wrapper_data.extend((w.data.len() as u16).to_be_bytes().to_vec());
+        wrapper_data.extend(w.data.clone());
+    }
+
+    wrapper_data
+}
+
 pub fn liquidity_interaction(
     liquidity: &Liquidity,
     slippage: &slippage::Parameters,