feat(CA): adding USDS asset support (#981)

Author: geekbrother

integration/chain_orchestrator.test.ts

@@ -31,6 +31,11 @@ describe('Chain abstraction orchestrator', () => {
   usdt_funds[chain_id_arbitrum] = 3_388_000;
   usdt_funds[chain_id_optimism] = 1_050_000;
 
+  const usds_token_symbol = "USDS";
+  let usds_funds = {};
+  // Using string amouns for USDS, as it has 18 decimals
+  usds_funds[chain_id_optimism] = "902165684795715063";
+
   // Amount to send to Optimism
   const amount_to_send = 3_000_000
 
@@ -42,6 +47,9 @@ describe('Chain abstraction orchestrator', () => {
   usdt_contracts[chain_id_optimism] = "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58";
   usdt_contracts[chain_id_arbitrum] = "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
   usdt_contracts[chain_id_base] = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2";
+  let usds_contracts = {};
+  usds_contracts[chain_id_optimism] = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
+  usds_contracts[chain_id_arbitrum] = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 
   let orchestration_id = "";
 
@@ -283,7 +291,7 @@ describe('Chain abstraction orchestrator', () => {
   })
 
   it('bridging routes (routes available, USDT Optimism → USDT Arbitrum)', async () => {
-    // Sending USDT to Arbitrum, but having the USDT balance on Optimism.
+    // Sending USDT on Arbitrum, but having the USDT balance on Optimism.
     let amount_to_send = usdt_funds[chain_id_arbitrum] + 500_000;
 
     const data_encoded = erc20Interface.encodeFunctionData('transfer', [
@@ -313,6 +321,38 @@ describe('Chain abstraction orchestrator', () => {
     expect(data.transactions.length).toBe(2)
   })
 
+  it('bridging routes (routes available, USDC Base → USDS(DAI) Optimism)', async () => {
+    // Sending USDS on Optimism, but having the USDC balance on Base.
+    let amount_to_send = "2802165684795715100";
+
+    const data_encoded = erc20Interface.encodeFunctionData('transfer', [
+      receiver_address,
+      amount_to_send,
+    ]);
+
+    let transactionObj = {
+      transaction: {
+        from: from_address_with_funds,
+        to: usds_contracts[chain_id_optimism],
+        value: "0x00", // Zero native tokens
+        input: data_encoded,
+        chainId: chain_id_optimism,
+      }
+    }
+
+    let resp: any = await httpClient.post(
+      `${baseUrl}/v1/ca/orchestrator/route?projectId=${projectId}`,
+      transactionObj
+    )
+    expect(resp.status).toBe(200)
+
+    const data = resp.data
+    expect(typeof data.orchestrationId).toBe('string')
+
+    // Expecting 2 transactions in the route
+    expect(data.transactions.length).toBe(2)
+  })
+
   it('bridging status', async () => {
     let resp: any = await httpClient.get(
       `${baseUrl}/v1/ca/orchestrator/status?projectId=${projectId}&orchestrationId=${orchestration_id}`,

src/handlers/chain_agnostic/assets.rs

@@ -38,6 +38,13 @@ static USDT_CONTRACTS: phf::Map<&'static str, Address> = phf_map! {
     "eip155:42161" => address!("Fd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
 };
 
+static USDS_CONTRACTS: phf::Map<&'static str, Address> = phf_map! {
+    // Optimism
+    "eip155:10" => address!("DA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+    // Arbitrum
+    "eip155:42161" => address!("DA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+};
+
 pub static BRIDGING_ASSETS: phf::Map<&'static str, AssetEntry> = phf_map! {
     "USDC" => AssetEntry {
         metadata: AssetMetadata {
@@ -68,4 +75,18 @@ pub static BRIDGING_ASSETS: phf::Map<&'static str, AssetEntry> = phf_map! {
         },
         contracts: &USDT_CONTRACTS,
     },
+    "USDS" => AssetEntry {
+        metadata: AssetMetadata {
+            decimals: 18,
+        },
+        simulation: SimulationParams {
+            // Must be in sync with the `USDS_CONTRACTS` from above
+            balance_storage_slots: &phf_map! {
+                "eip155:10" => 2u64,
+                "eip155:42161" => 2u64,
+            },
+            balance: 99000000000000000000000,
+        },
+        contracts: &USDS_CONTRACTS,
+    },
 };

src/handlers/chain_agnostic/mod.rs

@@ -13,7 +13,7 @@ use {
     assets::{SimulationParams, BRIDGING_ASSETS},
     ethers::{types::H160 as EthersH160, utils::keccak256},
     serde::{Deserialize, Serialize},
-    std::{collections::HashMap, str::FromStr, sync::Arc},
+    std::{cmp::Ordering, collections::HashMap, str::FromStr, sync::Arc},
     tracing::debug,
     yttrium::chain_abstraction::api::Transaction,
 };
@@ -23,7 +23,7 @@ pub mod route;
 pub mod status;
 
 /// How much to multiply the bridging fee amount to cover bridging fee volatility
-pub const BRIDGING_FEE_SLIPPAGE: i8 = 75; // 75%
+pub const BRIDGING_FEE_SLIPPAGE: i16 = 200; // 200%
 
 /// Bridging timeout in seconds
 pub const BRIDGING_TIMEOUT: u64 = 1800; // 30 minutes
@@ -125,6 +125,7 @@ pub struct BridgingAsset {
 /// Checking available assets amount for bridging excluding the initial transaction
 /// asset, prioritizing the asset with the highest balance or the asset with the
 /// same symbol to avoid unnecessary swapping
+#[allow(clippy::too_many_arguments)]
 pub async fn check_bridging_for_erc20_transfer(
     rpc_project_id: String,
     session_id: Option<String>,
@@ -135,6 +136,8 @@ pub async fn check_bridging_for_erc20_transfer(
     exclude_contract_address: Address,
     // Using the same asset as a priority for bridging
     token_symbol_priority: String,
+    // Applying token decimals for the value to compare between different tokens
+    amount_token_decimals: u8,
 ) -> Result<Option<BridgingAsset>, RpcError> {
     // Check ERC20 tokens balance for each of supported assets
     let mut contracts_per_chain: HashMap<(String, String, u8), Vec<String>> = HashMap::new();
@@ -168,7 +171,8 @@ pub async fn check_bridging_for_erc20_transfer(
         )
         .await?;
         for (contract_address, current_balance) in erc20_balances {
-            if current_balance >= value {
+            // Check if the balance compared to the transfer value is enough, applied to the transfer token decimals
+            if convert_amount(current_balance, decimals, amount_token_decimals) >= value {
                 // Use the priority asset if found
                 if token_symbol == token_symbol_priority {
                     return Ok(Some(BridgingAsset {
@@ -314,3 +318,49 @@ pub async fn get_assets_changes_from_simulation(
 
     Ok((asset_changes, gas_used))
 }
+
+/// Convert the amount between different decimals
+pub fn convert_amount(amount: U256, from_decimals: u8, to_decimals: u8) -> U256 {
+    match from_decimals.cmp(&to_decimals) {
+        Ordering::Equal => amount,
+        Ordering::Greater => {
+            // Reducing decimals: divide by 10^(from_decimals - to_decimals)
+            let diff = from_decimals - to_decimals;
+            let exp = U256::from(diff as u64);
+            let factor = U256::from(10).pow(exp);
+            amount / factor
+        }
+        Ordering::Less => {
+            // Increasing decimals: multiply by 10^(to_decimals - from_decimals)
+            let diff = to_decimals - from_decimals;
+            let exp = U256::from(diff as u64);
+            let factor = U256::from(10).pow(exp);
+            amount * factor
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_convert_amount() {
+        let amount = U256::from_str("12345678901234567890").unwrap();
+        let converted = convert_amount(amount, 18, 18);
+        assert_eq!(converted, amount);
+
+        // Converting 500 USDT (6 decimals) to 18 decimals.
+        let usdt_amount = U256::from(500_000_000u64);
+        let converted = convert_amount(usdt_amount, 6, 18);
+        let expected = U256::from_str("500000000000000000000").unwrap();
+        assert_eq!(converted, expected);
+
+        // Converting 500 DAI (18 decimals) to 6 decimals.
+        let dai_amount = U256::from_str("500000000000000000000").unwrap();
+        let converted = convert_amount(dai_amount, 18, 6);
+        let expected = U256::from(500_000_000u64);
+        assert_eq!(converted, expected);
+    }
+}

src/handlers/chain_agnostic/route.rs

@@ -1,6 +1,6 @@
 use {
     super::{
-        super::HANDLER_TASK_METRICS, check_bridging_for_erc20_transfer,
+        super::HANDLER_TASK_METRICS, check_bridging_for_erc20_transfer, convert_amount,
         find_supported_bridging_asset, get_assets_changes_from_simulation, BridgingStatus,
         StorageBridgingItem, BRIDGING_FEE_SLIPPAGE, STATUS_POLLING_INTERVAL,
     },
@@ -302,7 +302,7 @@ async fn handler_internal(
             .add_ca_no_bridging_needed(ChainAbstractionNoBridgingNeededType::SufficientFunds);
         return Ok(no_bridging_needed_response.into_response());
     }
-    let erc20_topup_value = asset_transfer_value - erc20_balance;
+    let mut erc20_topup_value = asset_transfer_value - erc20_balance;
 
     // Check for possible bridging funds by iterating over supported assets
     // or return an insufficient funds error
@@ -314,6 +314,7 @@ async fn handler_internal(
         initial_transaction.chain_id.clone(),
         asset_transfer_contract,
         initial_tx_token_symbol.clone(),
+        initial_tx_token_decimals,
     )
     .await?
     else {
@@ -333,6 +334,13 @@ async fn handler_internal(
     let bridge_decimals = bridging_asset.decimals;
     let current_bridging_asset_balance = bridging_asset.current_balance;
 
+    // Applying decimals differences between initial token and bridging token
+    erc20_topup_value = convert_amount(
+        erc20_topup_value,
+        initial_tx_token_decimals,
+        bridge_decimals,
+    );
+
     // Get Quotes for the bridging
     let quotes = state
         .providers
@@ -374,7 +382,8 @@ async fn handler_internal(
     let bridging_amount = serde_json::from_value::<QuoteRoute>(best_route.clone())?.to_amount;
     let bridging_amount =
         U256::from_str(&bridging_amount).map_err(|_| RpcError::InvalidValue(bridging_amount))?;
-    let bridging_fee = erc20_topup_value - bridging_amount;
+    let bridging_fee = erc20_topup_value
+        - convert_amount(bridging_amount, initial_tx_token_decimals, bridge_decimals);
 
     // Calculate the required bridging topup amount with the bridging fee
     // and bridging fee * slippage to cover volatility
@@ -437,7 +446,9 @@ async fn handler_internal(
     let bridging_amount = serde_json::from_value::<QuoteRoute>(best_route.clone())?.to_amount;
     let bridging_amount =
         U256::from_str(&bridging_amount).map_err(|_| RpcError::InvalidValue(bridging_amount))?;
-    if erc20_topup_value > bridging_amount {
+    if erc20_topup_value
+        > convert_amount(bridging_amount, initial_tx_token_decimals, bridge_decimals)
+    {
         error!(
             "The final bridging amount:{} is less than the topup amount:{}",
             bridging_amount, erc20_topup_value