feat(CA): adding USDT asset to the chain abstraction (#882)

* feat(CA): adding USDT chain abstraction support

* fix: updating the integration tests

Author: geekbrother

integration/chain_orchestrator.test.ts

@@ -9,30 +9,47 @@ describe('Chain abstraction orchestrator', () => {
     'function approve(address spender, uint256 amount) public returns (bool)'
   ]);
 
-  // Address with 3 USDC on Base chain
+  // Funding address
   const from_address_with_funds = "0x2aae531a81461f029cd55cb46703211c9227ba05";
-  const usdc_funds_on_base = 3_000_000;
-  const usdc_funds_on_optimism = 1_057_151;
+
+  // Receiver address
+  const receiver_address = "0x739ff389c8eBd9339E69611d46Eec6212179BB67";
+
+  // Supported chains
+  const chain_id_optimism = "eip155:10";
+  const chain_id_base = "eip155:8453";
+  const chain_id_arbitrum = "eip155:42161";
+  
+  // Current funds on different chains
   const usdc_token_symbol = "USDC";
+  let usdc_funds = {};
+  usdc_funds[chain_id_base] = 3_000_000;
+  usdc_funds[chain_id_optimism] = 1_057_151;
+
+  const usdt_token_symbol = "USDT";
+  let usdt_funds = {};
+  usdt_funds[chain_id_arbitrum] = 3_388_000;
+  usdt_funds[chain_id_optimism] = 1_050_000;
+
   // Amount to send to Optimism
   const amount_to_send = 3_000_000
   // Amount bridging slippage
   const amount_slippage = 2; // +2% topup
-  // How much needs to be topped up
-  const amount_to_topup = Math.round(amount_to_send - usdc_funds_on_optimism);
-  const amount_to_topup_with_fees = Math.round(((amount_to_topup * amount_slippage) / 100) + amount_to_topup);
-
-  const receiver_address = "0x739ff389c8eBd9339E69611d46Eec6212179BB67";
-  const chain_id_optimism = "eip155:10";
-  const usdc_contract_optimism = "0x0b2c639c533813f4aa9d7837caf62653d097ff85";
-  const chain_id_base = "eip155:8453";
-  const usdc_contract_base = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+  
+  let usdc_contracts = {};
+  usdc_contracts[chain_id_optimism] = "0x0b2c639c533813f4aa9d7837caf62653d097ff85";
+  usdc_contracts[chain_id_base] = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+  usdc_contracts[chain_id_arbitrum] = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+  let usdt_contracts = {};
+  usdt_contracts[chain_id_optimism] = "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58";
+  usdt_contracts[chain_id_arbitrum] = "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
+  usdt_contracts[chain_id_base] = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2";
 
   let orchestration_id = "";
 
   it('bridging unavailable (insufficient funds)', async () => {
     // Having the USDC balance on Base chain less then the amount to send
-    const amount_to_send_in_decimals = usdc_funds_on_base + 10_000_000
+    const amount_to_send_in_decimals = usdc_funds[chain_id_base] + 10_000_000
     const data_encoded = erc20Interface.encodeFunctionData('transfer', [
       receiver_address,
       amount_to_send_in_decimals,
@@ -41,7 +58,7 @@ describe('Chain abstraction orchestrator', () => {
     let transactionObj = {
       transaction: {
         from: from_address_with_funds,
-        to: usdc_contract_optimism,
+        to: usdc_contracts[chain_id_optimism],
         value: "0x00", // Zero native tokens
         input: data_encoded,
         chainId: chain_id_optimism,
@@ -58,7 +75,7 @@ describe('Chain abstraction orchestrator', () => {
 
   it('bridging unavailable (empty wallet)', async () => {
     // Checking an empty wallet
-    const amount_to_send_in_decimals = usdc_funds_on_base
+    const amount_to_send_in_decimals = usdc_funds[chain_id_base]
     const empty_wallet_address = ethers.Wallet.createRandom().address
     const data_encoded = erc20Interface.encodeFunctionData('transfer', [
       receiver_address,
@@ -68,7 +85,7 @@ describe('Chain abstraction orchestrator', () => {
     let transactionObj = {
       transaction: {
         from: empty_wallet_address,
-        to: usdc_contract_optimism,
+        to: usdc_contracts[chain_id_optimism],
         value: "0x00", // Zero native tokens
         input: data_encoded,
         chainId: chain_id_optimism,
@@ -94,7 +111,7 @@ describe('Chain abstraction orchestrator', () => {
     let transactionObj = {
       transaction: {
         from: from_address_with_funds,
-        to: usdc_contract_optimism,
+        to: usdc_contracts[chain_id_optimism],
         value: "0x00", // Zero native tokens
         input: data_encoded,
         chainId: chain_id_optimism,
@@ -110,8 +127,14 @@ describe('Chain abstraction orchestrator', () => {
 
   })
 
-  it('bridging routes (routes available)', async () => {
-    // Sending USDC to Optimism, but having the USDC balance on Base chain
+  it('bridging routes (routes available, USDC Optimism ⇄ USDT Arbitrum)', async () => {
+    // Sending USDC to Optimism, but having the maximum balance of USDT on Arbitrum chain
+    // which expected to be used for bridging
+
+    // How much needs to be topped up
+    const amount_to_topup = Math.round(amount_to_send - usdc_funds[chain_id_optimism]);
+    const amount_to_topup_with_fees = Math.round(((amount_to_topup * amount_slippage) / 100) + amount_to_topup);
+
     const data_encoded = erc20Interface.encodeFunctionData('transfer', [
       receiver_address,
       amount_to_send,
@@ -120,7 +143,7 @@ describe('Chain abstraction orchestrator', () => {
     let transactionObj = {
       transaction: {
         from: from_address_with_funds,
-        to: usdc_contract_optimism,
+        to: usdc_contracts[chain_id_optimism],
         value: "0x00", // Zero native tokens
         input: data_encoded,
         chainId: chain_id_optimism,
@@ -140,31 +163,31 @@ describe('Chain abstraction orchestrator', () => {
 
     // First transaction expected to be the approval transaction
     const approvalTransaction = data.transactions[0]
-    expect(approvalTransaction.chainId).toBe(chain_id_base)
+    expect(approvalTransaction.chainId).toBe(chain_id_arbitrum)
     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 Base
+    // Second transaction expected to be the bridging to the Arbitrum
     const bridgingTransaction = data.transactions[1]
-    expect(bridgingTransaction.chainId).toBe(chain_id_base)
+    expect(bridgingTransaction.chainId).toBe(chain_id_arbitrum)
     expect(bridgingTransaction.nonce).not.toBe("0x00")
     expect(() => BigInt(approvalTransaction.gasLimit)).not.toThrow();
 
     // Check for the initialTransaction
     const initialTransaction = data.initialTransaction;
     expect(initialTransaction.from).toBe(from_address_with_funds.toLowerCase());
-    expect(initialTransaction.to).toBe(usdc_contract_optimism.toLowerCase());
+    expect(initialTransaction.to).toBe(usdc_contracts[chain_id_optimism].toLowerCase());
     expect(initialTransaction.gasLimit).not.toBe("0x00");
 
     // Check the metadata fundingFrom
     const fundingFrom = data.metadata.fundingFrom[0]
-    expect(fundingFrom.chainId).toBe(chain_id_base)
-    expect(fundingFrom.symbol).toBe(usdc_token_symbol)
-    expect(fundingFrom.tokenContract).toBe(usdc_contract_base)
+    expect(fundingFrom.chainId).toBe(chain_id_arbitrum)
+    expect(fundingFrom.symbol).toBe(usdt_token_symbol)
+    expect(fundingFrom.tokenContract).toBe(usdt_contracts[chain_id_arbitrum].toLowerCase())
     if (BigInt(fundingFrom.amount) <= BigInt(amount_to_topup_with_fees)) {
       throw new Error(`Expected amount is lower then the minimal required`);
     }
@@ -175,7 +198,86 @@ describe('Chain abstraction orchestrator', () => {
     const initialTransactionMetadata = data.metadata.initialTransaction
     expect(initialTransactionMetadata.symbol).toBe(usdc_token_symbol)
     expect(initialTransactionMetadata.transferTo).toBe(receiver_address.toLowerCase())
-    expect(initialTransactionMetadata.tokenContract).toBe(usdc_contract_optimism.toLowerCase())
+    expect(initialTransactionMetadata.tokenContract).toBe(usdc_contracts[chain_id_optimism].toLowerCase())
+
+    // Check the metadata checkIn
+    expect(typeof data.metadata.checkIn).toBe('number')
+
+    // Set the Orchestration ID for the next test
+    orchestration_id = data.orchestrationId;
+  })
+
+  it('bridging routes (routes available, USDT Optimism ⇄ USDT Arbitrum)', async () => {
+    // Sending USDT to Optimism, but having the USDT balance on Arbitrum.
+
+    // How much needs to be topped up
+    const amount_to_topup = Math.round(amount_to_send - usdt_funds[chain_id_optimism]);
+    const amount_to_topup_with_fees = Math.round(((amount_to_topup * amount_slippage) / 100) + amount_to_topup);
+
+    const data_encoded = erc20Interface.encodeFunctionData('transfer', [
+      receiver_address,
+      amount_to_send,
+    ]);
+
+    let transactionObj = {
+      transaction: {
+        from: from_address_with_funds,
+        to: usdt_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)
+
+    // First transaction expected to be the approval transaction
+    const approvalTransaction = data.transactions[0]
+    expect(approvalTransaction.chainId).toBe(chain_id_arbitrum)
+    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
+    const bridgingTransaction = data.transactions[1]
+    expect(bridgingTransaction.chainId).toBe(chain_id_arbitrum)
+    expect(bridgingTransaction.nonce).not.toBe("0x00")
+    expect(() => BigInt(approvalTransaction.gasLimit)).not.toThrow();
+
+    // Check for the initialTransaction
+    const initialTransaction = data.initialTransaction;
+    expect(initialTransaction.from).toBe(from_address_with_funds.toLowerCase());
+    expect(initialTransaction.to).toBe(usdt_contracts[chain_id_optimism].toLowerCase());
+    expect(initialTransaction.gasLimit).not.toBe("0x00");
+
+    // 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())
+    if (BigInt(fundingFrom.amount) <= BigInt(amount_to_topup_with_fees)) {
+      throw new Error(`Expected amount is lower then the minimal required`);
+    }
+    if (BigInt(fundingFrom.bridgingFee) != BigInt(fundingFrom.amount - amount_to_topup)){
+      throw new Error(`Expected bridging fee is incorrect. `);
+    }
+    // Check the initialTransaction metadata
+    const initialTransactionMetadata = data.metadata.initialTransaction
+    expect(initialTransactionMetadata.symbol).toBe(usdt_token_symbol)
+    expect(initialTransactionMetadata.transferTo).toBe(receiver_address.toLowerCase())
+    expect(initialTransactionMetadata.tokenContract).toBe(usdt_contracts[chain_id_optimism].toLowerCase())
 
     // Check the metadata checkIn
     expect(typeof data.metadata.checkIn).toBe('number')

src/handlers/chain_agnostic/assets.rs

@@ -0,0 +1,64 @@
+use {
+    alloy::primitives::{address, Address},
+    phf::phf_map,
+};
+
+pub struct AssetMetadata {
+    pub decimals: u8,
+}
+
+/// Asset simulation parameters to override the asset's balance state
+pub struct SimulationParams {
+    /// Asset contract balance storage slot number
+    pub balance_storage_slot: u64,
+    /// Balance override for the asset
+    pub balance: u128,
+}
+
+pub struct AssetEntry {
+    pub metadata: AssetMetadata,
+    pub simulation: SimulationParams,
+    /// Asset contracts per CAIP-2 chain ID
+    pub contracts: &'static phf::Map<&'static str, Address>,
+}
+
+static USDC_CONTRACTS: phf::Map<&'static str, Address> = phf_map! {
+    // Optimism
+    "eip155:10" => address!("0b2c639c533813f4aa9d7837caf62653d097ff85"),
+    // Base
+    "eip155:8453" => address!("833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+    // Arbitrum
+    "eip155:42161" => address!("af88d065e77c8cC2239327C5EDb3A432268e5831"),
+};
+
+static USDT_CONTRACTS: phf::Map<&'static str, Address> = phf_map! {
+    // Optimism
+    "eip155:10" => address!("94b008aA00579c1307B0EF2c499aD98a8ce58e58"),
+    // Base
+    "eip155:8453" => address!("fde4C96c8593536E31F229EA8f37b2ADa2699bb2"),
+    // Arbitrum
+    "eip155:42161" => address!("Fd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
+};
+
+pub static BRIDGING_ASSETS: phf::Map<&'static str, AssetEntry> = phf_map! {
+    "USDC" => AssetEntry {
+        metadata: AssetMetadata {
+            decimals: 6,
+        },
+        simulation: SimulationParams {
+            balance_storage_slot: 9,
+            balance: 99000000000,
+        },
+        contracts: &USDC_CONTRACTS,
+    },
+    "USDT" => AssetEntry {
+        metadata: AssetMetadata {
+            decimals: 6,
+        },
+        simulation: SimulationParams {
+            balance_storage_slot: 0,
+            balance: 99000000000,
+        },
+        contracts: &USDT_CONTRACTS,
+    },
+};

src/handlers/chain_agnostic/mod.rs

@@ -9,15 +9,16 @@ use {
         utils::crypto::get_erc20_contract_balance,
         Metrics,
     },
-    alloy::primitives::{address, Address, B256, U256},
+    alloy::primitives::{Address, B256, U256},
+    assets::{SimulationParams, BRIDGING_ASSETS},
     ethers::{types::H160 as EthersH160, utils::keccak256},
-    phf::phf_map,
     serde::{Deserialize, Serialize},
     std::{collections::HashMap, str::FromStr, sync::Arc},
     tracing::debug,
     yttrium::chain_abstraction::api::Transaction,
 };
 
+pub mod assets;
 pub mod route;
 pub mod status;
 
@@ -27,19 +28,6 @@ pub const BRIDGING_AMOUNT_SLIPPAGE: i8 = 50; // 50%
 /// Bridging timeout in seconds
 pub const BRIDGING_TIMEOUT: u64 = 1800; // 30 minutes
 
-/// Available assets for Bridging
-pub static BRIDGING_AVAILABLE_ASSETS: phf::Map<&'static str, phf::Map<&'static str, Address>> = phf_map! {
-  "USDC" => phf_map! {
-      // Optimism
-      "eip155:10" => address!("0b2c639c533813f4aa9d7837caf62653d097ff85"),
-      // Base
-      "eip155:8453" => address!("833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
-      // Arbitrum
-      "eip155:42161" => address!("af88d065e77c8cC2239327C5EDb3A432268e5831"),
-  },
-};
-pub const USDC_DECIMALS: u8 = 6;
-
 /// The status polling interval in ms for the client
 pub const STATUS_POLLING_INTERVAL: u64 = 3000; // 3 seconds
 
@@ -66,25 +54,34 @@ pub enum BridgingStatus {
     Error,
 }
 
-/// Return available assets contracts addresses for the given chain_id
-pub fn get_bridging_assets_contracts_for_chain(chain_id: &str) -> Vec<String> {
-    BRIDGING_AVAILABLE_ASSETS
+/// Return available assets names and contract addresses for the given chain_id
+pub fn get_bridging_assets_contracts_for_chain(chain_id: &str) -> Vec<(String, Address)> {
+    BRIDGING_ASSETS
         .entries()
-        .filter_map(|(_token_symbol, chain_map)| {
-            chain_map
+        .filter_map(|(token_symbol, asset_entry)| {
+            asset_entry
+                .contracts
                 .entries()
                 .find(|(chain, _)| **chain == chain_id)
-                .map(|(_, contract_address)| contract_address.to_string())
+                .map(|(_, contract_address)| (token_symbol.to_string(), *contract_address))
         })
         .collect()
 }
 
+/// Returns simulation params for the bridging asset
+pub fn get_simulation_params_for_asset(asset_name: &str) -> Option<&SimulationParams> {
+    BRIDGING_ASSETS
+        .entries()
+        .find(|(name, _)| **name == asset_name)
+        .map(|(_, asset_entry)| &asset_entry.simulation)
+}
+
 /// Check is the address is supported bridging asset and return the token symbol and decimals
 pub fn find_supported_bridging_asset(chain_id: &str, contract: Address) -> Option<(String, u8)> {
-    for (symbol, chain_map) in BRIDGING_AVAILABLE_ASSETS.entries() {
-        for (chain, contract_address) in chain_map.entries() {
+    for (symbol, asset_entry) in BRIDGING_ASSETS.entries() {
+        for (chain, contract_address) in asset_entry.contracts.entries() {
             if *chain == chain_id && contract == *contract_address {
-                return Some((symbol.to_string(), USDC_DECIMALS));
+                return Some((symbol.to_string(), asset_entry.metadata.decimals));
             }
         }
     }
@@ -133,20 +130,25 @@ pub async fn check_bridging_for_erc20_transfer(
     exclude_contract_address: Address,
 ) -> Result<Option<BridgingAsset>, RpcError> {
     // Check ERC20 tokens balance for each of supported assets
-    let mut contracts_per_chain: HashMap<(String, String), Vec<String>> = HashMap::new();
-    for (token_symbol, chain_map) in BRIDGING_AVAILABLE_ASSETS.entries() {
-        for (chain_id, contract_address) in chain_map.entries() {
+    let mut contracts_per_chain: HashMap<(String, String, u8), Vec<String>> = HashMap::new();
+    for (token_symbol, asset_entry) in BRIDGING_ASSETS.entries() {
+        for (chain_id, contract_address) in asset_entry.contracts.entries() {
             if *chain_id == exclude_chain_id && *contract_address == exclude_contract_address {
                 continue;
             }
             contracts_per_chain
-                .entry((token_symbol.to_string(), (*chain_id).to_string()))
+                .entry((
+                    token_symbol.to_string(),
+                    (*chain_id).to_string(),
+                    asset_entry.metadata.decimals,
+                ))
                 .or_default()
                 .push((*contract_address).to_string());
         }
     }
-    // Making the check for each chain_id
-    for ((token_symbol, chain_id), contracts) in contracts_per_chain {
+    // Making the check for each chain_id and use the asset with the highest balance
+    let mut bridging_asset_found = None;
+    for ((token_symbol, chain_id, decimals), contracts) in contracts_per_chain {
         let erc20_balances = check_erc20_balances(
             rpc_project_id.clone(),
             sender,
@@ -159,18 +161,27 @@ pub async fn check_bridging_for_erc20_transfer(
         .await?;
         for (contract_address, current_balance) in erc20_balances {
             if current_balance >= value {
-                return Ok(Some(BridgingAsset {
-                    chain_id,
-                    token_symbol,
+                // Use the asset with the highest found balance
+                if let Some(BridgingAsset {
+                    current_balance: existing_balance,
+                    ..
+                }) = &bridging_asset_found
+                {
+                    if current_balance <= *existing_balance {
+                        continue;
+                    }
+                }
+                bridging_asset_found = Some(BridgingAsset {
+                    chain_id: chain_id.clone(),
+                    token_symbol: token_symbol.clone(),
                     contract_address,
                     current_balance,
-                    // We are supporting only USDC for now which have a fixed decimals
-                    decimals: USDC_DECIMALS,
-                }));
+                    decimals,
+                });
             }
         }
     }
-    Ok(None)
+    Ok(bridging_asset_found)
 }
 
 /// Compute the simulation state override balance for a given balance
@@ -207,23 +218,24 @@ pub async fn get_assets_changes_from_simulation(
     metrics: Arc<Metrics>,
 ) -> Result<(Vec<Erc20AssetChange>, u64), RpcError> {
     // Fill the state overrides for the source address for each of the supported
-    // assets on the initial tx chain
+    // assets on the initial tx chain for the balance slot
     let state_overrides = {
         let mut state_overrides = HashMap::new();
         let assets_contracts =
             get_bridging_assets_contracts_for_chain(&transaction.chain_id.clone());
         let mut account_state = HashMap::new();
-        account_state.insert(
-            // Since we are using only USDC for the bridging,
-            // we can hardcode the storage slot for the contract which is 9
-            compute_simulation_storage_slot(transaction.from, 9),
-            compute_simulation_balance(99000000000),
-        );
-        for contract in assets_contracts {
-            state_overrides.insert(
-                Address::from_str(&contract).unwrap_or_default(),
-                account_state.clone(),
+        for (asset_name, asset_contract) in assets_contracts {
+            let Some(simulation_params) = get_simulation_params_for_asset(&asset_name) else {
+                continue;
+            };
+            account_state.insert(
+                compute_simulation_storage_slot(
+                    transaction.from,
+                    simulation_params.balance_storage_slot,
+                ),
+                compute_simulation_balance(simulation_params.balance),
             );
+            state_overrides.insert(asset_contract, account_state.clone());
         }
         state_overrides
     };