feat(CA): prioritizing the same asset for bridging routes (#900)

Author: geekbrother

integration/chain_orchestrator.test.ts

@@ -127,8 +127,8 @@ describe('Chain abstraction orchestrator', () => {
 
   })
 
-  it('bridging routes (routes available, USDC Optimism ⇄ USDT Arbitrum)', async () => {
-    // Sending USDC to Optimism, but having the maximum balance of USDT on Arbitrum chain
+  it('bridging routes (routes available, USDC Optimism ⇄ USDC Base)', async () => {
+    // Sending USDC to Optimism, but having the balance of USDC on Base chain
     // which expected to be used for bridging
 
     // How much needs to be topped up
@@ -163,17 +163,17 @@ describe('Chain abstraction orchestrator', () => {
 
     // First transaction expected to be the approval transaction
     const approvalTransaction = data.transactions[0]
-    expect(approvalTransaction.chainId).toBe(chain_id_arbitrum)
+    expect(approvalTransaction.chainId).toBe(chain_id_base)
     expect(approvalTransaction.nonce).not.toBe("0x00")
     expect(() => BigInt(approvalTransaction.gasLimit)).not.toThrow();
     const decodedData = erc20Interface.decodeFunctionData('approve', approvalTransaction.input);
     if (decodedData.amount < BigInt(amount_to_topup_with_fees)) {
       throw new Error(`Expected amount is lower then the minimal required`);
     }
 
-    // Second transaction expected to be the bridging to the Arbitrum
+    // Second transaction expected to be the bridging to the Base
     const bridgingTransaction = data.transactions[1]
-    expect(bridgingTransaction.chainId).toBe(chain_id_arbitrum)
+    expect(bridgingTransaction.chainId).toBe(chain_id_base)
     expect(bridgingTransaction.nonce).not.toBe("0x00")
     expect(() => BigInt(approvalTransaction.gasLimit)).not.toThrow();
 
@@ -185,9 +185,9 @@ describe('Chain abstraction orchestrator', () => {
 
     // Check the metadata fundingFrom
     const fundingFrom = data.metadata.fundingFrom[0]
-    expect(fundingFrom.chainId).toBe(chain_id_arbitrum)
-    expect(fundingFrom.symbol).toBe(usdt_token_symbol)
-    expect(fundingFrom.tokenContract).toBe(usdt_contracts[chain_id_arbitrum].toLowerCase())
+    expect(fundingFrom.chainId).toBe(chain_id_base)
+    expect(fundingFrom.symbol).toBe(usdc_token_symbol)
+    expect(fundingFrom.tokenContract).toBe(usdc_contracts[chain_id_base].toLowerCase())
     if (BigInt(fundingFrom.amount) <= BigInt(amount_to_topup_with_fees)) {
       throw new Error(`Expected amount is lower then the minimal required`);
     }

src/handlers/chain_agnostic/mod.rs

@@ -120,14 +120,18 @@ pub struct BridgingAsset {
     pub current_balance: U256,
 }
 
-/// Check available assets for bridging and return
-/// the chain_id, token symbol and contract_address
+/// 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
 pub async fn check_bridging_for_erc20_transfer(
     rpc_project_id: String,
     value: U256,
     sender: Address,
+    // Exclude the initial transaction asset from the check
     exclude_chain_id: String,
     exclude_contract_address: Address,
+    // Using the same asset as a priority for bridging
+    token_symbol_priority: String,
 ) -> 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();
@@ -161,7 +165,18 @@ pub async fn check_bridging_for_erc20_transfer(
         .await?;
         for (contract_address, current_balance) in erc20_balances {
             if current_balance >= value {
-                // Use the asset with the highest found balance
+                // Use the priority asset if found
+                if token_symbol == token_symbol_priority {
+                    return Ok(Some(BridgingAsset {
+                        chain_id: chain_id.clone(),
+                        token_symbol: token_symbol.clone(),
+                        contract_address,
+                        current_balance,
+                        decimals,
+                    }));
+                }
+
+                // or use the asset with the highest found balance
                 if let Some(BridgingAsset {
                     current_balance: existing_balance,
                     ..

src/handlers/chain_agnostic/route.rs

@@ -246,6 +246,7 @@ async fn handler_internal(
         from_address,
         initial_transaction.chain_id.clone(),
         asset_transfer_contract,
+        initial_tx_token_symbol.clone(),
     )
     .await?
     else {