Solver crate forwards flashloans back to driver

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

@@ -224,6 +224,21 @@ pub const UID_LEN: usize = 56;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Uid(pub Bytes<[u8; UID_LEN]>);
 
+impl Uid {
+    pub fn owner(&self) -> eth::Address {
+        self.parts().1.into()
+    }
+
+    /// Splits an order UID into its parts.
+    fn parts(&self) -> (eth::H256, eth::H160, u32) {
+        (
+            eth::H256::from_slice(&self.0 .0[0..32]),
+            eth::H160::from_slice(&self.0 .0[32..52]),
+            u32::from_le_bytes(self.0 .0[52..].try_into().unwrap()),
+        )
+    }
+}
+
 impl Default for Uid {
     fn default() -> Self {
         Self([0; UID_LEN].into())

crates/driver/src/infra/config/file/load.rs

@@ -134,6 +134,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                 },
                 settle_queue_size: solver_config.settle_queue_size,
                 flashloans_enabled: config.flashloans_enabled,
+                flashloan_default_lender: eth::Address(config.flashloans_default_lender),
             }
         }))
         .await,

crates/driver/src/infra/config/file/mod.rs

@@ -5,7 +5,7 @@ use {
     serde::{Deserialize, Deserializer, Serialize},
     serde_with::serde_as,
     solver::solver::Arn,
-    std::{collections::HashMap, time::Duration},
+    std::{collections::HashMap, str::FromStr, time::Duration},
 };
 
 mod load;
@@ -81,6 +81,10 @@ struct Config {
     /// Whether the flashloans feature is enabled.
     #[serde(default)]
     flashloans_enabled: bool,
+
+    /// If no lender is specified in flashloan hint, use this default lender.
+    #[serde(default = "default_flashloans_lender")]
+    flashloans_default_lender: eth::H160,
 }
 
 #[serde_as]
@@ -684,6 +688,11 @@ fn default_simulation_bad_token_max_age() -> Duration {
     Duration::from_secs(600)
 }
 
+// SKY lending DAI token
+fn default_flashloans_lender() -> eth::H160 {
+    eth::H160::from_str("0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA").unwrap()
+}
+
 #[serde_as]
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]

crates/driver/src/infra/solver/dto/auction.rs

@@ -34,6 +34,7 @@ impl Auction {
         fee_handler: FeeHandler,
         solver_native_token: ManageNativeToken,
         flashloans_enabled: bool,
+        flashloan_default_lender: eth::Address,
     ) -> Self {
         let mut tokens: HashMap<eth::H160, _> = auction
             .tokens()
@@ -161,7 +162,14 @@ impl Auction {
                         ),
                         app_data: AppDataHash(order.app_data.hash().0.into()),
                         flashloan_hint: flashloans_enabled
-                            .then(|| order.app_data.flashloan().cloned().map(Into::into))
+                            .then(|| {
+                                order.app_data.flashloan().map(|flashloan| FlashloanHint {
+                                    lender: flashloan.lender.unwrap_or(flashloan_default_lender.0),
+                                    borrower: flashloan.borrower.unwrap_or(order.uid.owner().0),
+                                    token: flashloan.token,
+                                    amount: flashloan.amount,
+                                })
+                            })
                             .flatten(),
                         signature: order.signature.data.clone().into(),
                         signing_scheme: match order.signature.scheme {
@@ -609,24 +617,13 @@ struct ForeignLimitOrder {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FlashloanHint {
-    pub lender: Option<eth::H160>,
-    pub borrower: Option<eth::H160>,
+    pub lender: eth::H160,
+    pub borrower: eth::H160,
     pub token: eth::H160,
     #[serde_as(as = "serialize::U256")]
     pub amount: eth::U256,
 }
 
-impl From<app_data::Flashloan> for FlashloanHint {
-    fn from(value: app_data::Flashloan) -> Self {
-        Self {
-            lender: value.lender,
-            borrower: value.borrower,
-            token: value.token,
-            amount: value.amount,
-        }
-    }
-}
-
 fn fee_to_decimal(fee: liquidity::balancer::v2::Fee) -> bigdecimal::BigDecimal {
     bigdecimal::BigDecimal::new(fee.as_raw().to_big_int(), 18)
 }

crates/driver/src/infra/solver/mod.rs

@@ -129,6 +129,8 @@ pub struct Config {
     pub settle_queue_size: usize,
     /// Whether flashloan hints should be sent to the solver.
     pub flashloans_enabled: bool,
+    /// If no lender is specified in flashloan hint, use default one
+    pub flashloan_default_lender: eth::Address,
 }
 
 impl Solver {
@@ -231,6 +233,7 @@ impl Solver {
             self.config.fee_handler,
             self.config.solver_native_token,
             self.config.flashloans_enabled,
+            self.config.flashloan_default_lender,
         );
         // Only auctions with IDs are real auctions (/quote requests don't have an ID,
         // and it makes no sense to store them)

crates/driver/src/tests/setup/solver.rs

@@ -153,7 +153,12 @@ impl Solver {
                 "signingScheme": if config.quote { "eip1271" } else { "eip712" },
             });
             if let Some(flashloan) = quote.order.app_data.flashloan() {
-                order["flashloanHint"] = json!(Into::<FlashloanHint>::into(flashloan.clone()));
+                order["flashloanHint"] = json!(FlashloanHint {
+                    lender: flashloan.lender.unwrap(),
+                    borrower: flashloan.borrower.unwrap(),
+                    token: flashloan.token,
+                    amount: flashloan.amount
+                });
             }
             if config.fee_handler == FeeHandler::Solver {
                 order.as_object_mut().unwrap().insert(

crates/e2e/tests/e2e/cow_amm.rs

@@ -342,6 +342,7 @@ async fn cow_amm_jit(web3: Web3) {
         interactions: vec![],
         post_interactions: vec![],
         gas: None,
+        flashloans: vec![],
     }));
 
     // Drive solution
@@ -913,6 +914,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
             interactions: vec![],
             post_interactions: vec![],
             gas: None,
+            flashloans: vec![],
         }
     };
 

crates/e2e/tests/e2e/jit_orders.rs

@@ -167,6 +167,7 @@ async fn single_limit_order_test(web3: Web3) {
         interactions: vec![],
         post_interactions: vec![],
         gas: None,
+        flashloans: vec![],
     }));
 
     // Drive solution

crates/solvers-dto/src/auction.rs

@@ -52,6 +52,8 @@ pub struct Order {
     pub buy_token_destination: BuyTokenDestination,
     pub class: Class,
     pub app_data: AppDataHash,
+    #[serde(default)]
+    pub flashloan_hint: Option<FlashloanHint>,
     pub signing_scheme: SigningScheme,
     #[serde(with = "bytes_hex")]
     pub signature: Vec<u8>,
@@ -279,3 +281,14 @@ pub struct ForeignLimitOrder {
     #[serde_as(as = "HexOrDecimalU256")]
     pub taker_token_fee_amount: U256,
 }
+
+#[serde_as]
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FlashloanHint {
+    pub lender: H160,
+    pub borrower: H160,
+    pub token: H160,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub amount: U256,
+}

crates/solvers-dto/src/solution.rs

@@ -28,6 +28,8 @@ pub struct Solution {
     pub post_interactions: Vec<Call>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gas: Option<u64>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub flashloans: Vec<Flashloan>,
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -196,3 +198,14 @@ pub enum SigningScheme {
     PreSign,
     Eip1271,
 }
+
+#[serde_as]
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Flashloan {
+    pub lender: H160,
+    pub borrower: H160,
+    pub token: H160,
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub amount: U256,
+}

crates/solvers/openapi.yml

@@ -238,6 +238,8 @@ components:
         Contains information to hint at how how to make use of flashloans to settle the associated order.
       type: object
       required:
+        - lender
+        - borrower
         - token
         - amount
       properties:

crates/solvers/src/api/routes/solve/dto/auction.rs

@@ -58,6 +58,15 @@ pub fn to_domain(auction: &Auction) -> Result<auction::Auction, Error> {
                     Class::Limit => order::Class::Limit,
                 },
                 partially_fillable: order.partially_fillable,
+                flashloan_hint: order
+                    .flashloan_hint
+                    .clone()
+                    .map(|hint| order::FlashloanHint {
+                        lender: eth::Address(hint.lender),
+                        borrower: eth::Address(hint.borrower),
+                        token: eth::TokenAddress(hint.token),
+                        amount: hint.amount,
+                    }),
             })
             .collect(),
         liquidity: auction

crates/solvers/src/api/routes/solve/dto/solution.rs

@@ -115,6 +115,16 @@ pub fn from_domain(solutions: &[solution::Solution]) -> super::Solutions {
                     })
                     .collect(),
                 gas: solution.gas.map(|gas| gas.0.as_u64()),
+                flashloans: solution
+                    .flashloans
+                    .iter()
+                    .map(|loan| Flashloan {
+                        lender: loan.lender.0,
+                        borrower: loan.borrower.0,
+                        token: loan.token.0,
+                        amount: loan.amount,
+                    })
+                    .collect(),
             })
             .collect(),
     }

crates/solvers/src/domain/order.rs

@@ -15,6 +15,7 @@ pub struct Order {
     pub side: Side,
     pub class: Class,
     pub partially_fillable: bool,
+    pub flashloan_hint: Option<FlashloanHint>,
 }
 
 impl Order {
@@ -133,3 +134,12 @@ impl Debug for AppData {
             .finish()
     }
 }
+
+/// A hint for the solver to use a flashloan for this order.
+#[derive(Debug, Clone)]
+pub struct FlashloanHint {
+    pub lender: eth::Address,
+    pub borrower: eth::Address,
+    pub token: eth::TokenAddress,
+    pub amount: eth::U256,
+}

crates/solvers/src/domain/solution.rs

@@ -20,6 +20,7 @@ pub struct Solution {
     pub interactions: Vec<Interaction>,
     pub post_interactions: Vec<eth::Interaction>,
     pub gas: Option<eth::Gas>,
+    pub flashloans: Vec<Flashloan>,
 }
 
 impl Solution {
@@ -178,11 +179,22 @@ impl Single {
                 (order.sell.token, buy),
                 (order.buy.token, sell.checked_sub(surplus_fee)?),
             ]),
-            trades: vec![Trade::Fulfillment(Fulfillment::new(order, executed, fee)?)],
             pre_interactions: Default::default(),
             interactions,
             post_interactions: Default::default(),
             gas: Some(gas),
+            flashloans: order
+                .flashloan_hint
+                .clone()
+                .map(|hint| Flashloan {
+                    lender: hint.lender,
+                    borrower: hint.borrower,
+                    token: hint.token,
+                    amount: hint.amount,
+                })
+                .into_iter()
+                .collect(),
+            trades: vec![Trade::Fulfillment(Fulfillment::new(order, executed, fee)?)],
         })
     }
 }
@@ -368,3 +380,12 @@ pub const SETTLEMENT: u64 = 7365;
 /// Value was computed by taking 52 percentile median of `transfer()` costs
 /// of the 90% most traded tokens by volume in the month of Oct. 2021.
 pub const ERC20_TRANSFER: u64 = 27_513;
+
+/// A flashloan that is required to execute a solution.
+#[derive(Debug, Clone)]
+pub struct Flashloan {
+    pub lender: eth::Address,
+    pub borrower: eth::Address,
+    pub token: eth::TokenAddress,
+    pub amount: eth::U256,
+}