fix(core): use on-chain balance diff for native ETH realized amounts

Native ETH legs don't emit ERC20 Transfer events, so the previous code
fell back to the simulated amounts from strategy::Swap for both input and
output. This caused realized profit to reflect expected values rather than
actual on-chain outcomes.

Now try_from_receipts queries the signer's ETH balance at block N-1 and N:
- ETH in:  amount_in  = pre − post − gas_cost
- ETH out: amount_out = post − pre + gas_cost

The function is now async and takes a generic Provider, which
calculate_realized_profit in Trade constructs from each chain's rpc_url.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: quasystaty1

crates/core/src/state/swap.rs

@@ -5,18 +5,23 @@
 //! [`strategy::Swap`] which holds simulated/expected values computed before
 //! execution. Used by the execution worker to compute `RealizedProfit`.
 //!
-//! Native ETH inputs/outputs do not emit Transfer events — for those legs the
-//! expected amounts from the simulation are used as a fallback (see TODO in
-//! `try_from_receipts`).
+//! Native ETH inputs/outputs do not emit Transfer events. For those legs the
+//! actual amount is derived from the signer's balance diff across the receipt
+//! block: `pre_balance − post_balance − gas_cost` for ETH in, and
+//! `post_balance − pre_balance + gas_cost` for ETH out.
 
 use crate::{
     state::{erc20::Transfer, pair::Pair},
     strategy,
 };
-use alloy::{primitives::Address, rpc::types::TransactionReceipt};
+use alloy::{
+    primitives::Address,
+    providers::Provider,
+    rpc::types::TransactionReceipt,
+};
 use color_eyre::eyre::{self};
 use num_bigint::BigUint;
-use num_traits::CheckedAdd as _;
+use num_traits::{CheckedAdd as _, CheckedSub as _};
 use serde::{Deserialize, Serialize};
 use tycho_simulation::tycho_common::models::token::Token;
 
@@ -29,11 +34,11 @@ use tycho_simulation::tycho_common::models::token::Token;
 pub struct Swap {
     /// The token that was sold in the swap.
     pub token_in: Token,
-    /// Actual amount of token_in transferred (from Transfer events).
+    /// Actual amount of token_in transferred (from Transfer events or balance diff).
     pub amount_in: BigUint,
     /// The token that was received in the swap.
     pub token_out: Token,
-    /// Actual amount of token_out received (from Transfer events).
+    /// Actual amount of token_out received (from Transfer events or balance diff).
     pub amount_out: BigUint,
     /// Gas cost in wei (gas_used * effective_gas_price from receipt).
     pub gas_cost_eth: BigUint,
@@ -42,31 +47,66 @@ pub struct Swap {
 impl Swap {
     /// Parse actual swap amounts from a transaction receipt.
     ///
-    /// Iterates through the transaction logs to find ERC20 Transfer events for
-    /// the input and output tokens, summing the transferred amounts. Also extracts
-    /// the actual gas cost from the receipt.
-    pub fn try_from_receipts(
+    /// For ERC20 tokens, iterates through the transaction logs to find Transfer
+    /// events, summing the transferred amounts. For native ETH legs, queries the
+    /// signer's balance at block N-1 and block N to derive the actual amount from
+    /// the on-chain balance diff (assumes this is the only tx from the signer in
+    /// that block, which holds for kuma's serial execution model).
+    pub async fn try_from_receipts<P: Provider>(
         receipt: &TransactionReceipt,
         swap: strategy::Swap,
+        provider: &P,
     ) -> eyre::Result<Self> {
         let mut amount_in = BigUint::default();
         let mut amount_out = BigUint::default();
 
         let token_in_addr = Address::from_slice(&swap.token_in.address);
         let token_out_addr = Address::from_slice(&swap.token_out.address);
 
-        // Handle native ETH input (doesn't emit Transfer events)
-        if token_in_addr == Address::ZERO {
-            // TODO: For ETH input, we should get the actual transaction value from receipt
-            // For now, use the expected amount from the swap simulation
-            amount_in = swap.amount_in.clone();
-        }
+        let gas_units = BigUint::from(receipt.gas_used);
+        let wei_per_gas = BigUint::from(receipt.effective_gas_price);
+        let gas_cost_eth = gas_units * wei_per_gas;
+
+        if token_in_addr == Address::ZERO || token_out_addr == Address::ZERO {
+            let from = receipt.from;
+            let block_number = receipt
+                .block_number
+                .ok_or_else(|| eyre::eyre!("receipt missing block number"))?;
+            let pre_block = block_number
+                .checked_sub(1)
+                .ok_or_else(|| eyre::eyre!("block number is 0, cannot query pre-block balance"))?;
+
+            let pre_balance = provider
+                .get_balance(from)
+                .block_id(pre_block.into())
+                .await
+                .map_err(|e| eyre::eyre!("failed to get pre-block balance: {e}"))?;
+            let post_balance = provider
+                .get_balance(from)
+                .block_id(block_number.into())
+                .await
+                .map_err(|e| eyre::eyre!("failed to get post-block balance: {e}"))?;
+
+            let pre = BigUint::from_bytes_be(&pre_balance.to_be_bytes::<32>());
+            let post = BigUint::from_bytes_be(&post_balance.to_be_bytes::<32>());
 
-        // Handle native ETH output (doesn't emit Transfer events)
-        if token_out_addr == Address::ZERO {
-            // For ETH output, we need to calculate from balance changes
-            // This is more complex - for now use the expected amount from swap
-            amount_out = swap.amount_out.clone();
+            if token_in_addr == Address::ZERO {
+                // Signer spent amount_in + gas_cost, so balance dropped by that amount.
+                amount_in = pre
+                    .checked_sub(&post)
+                    .ok_or_else(|| eyre::eyre!("ETH balance increased unexpectedly on ETH-in swap"))?
+                    .checked_sub(&gas_cost_eth)
+                    .ok_or_else(|| eyre::eyre!("balance diff smaller than gas cost on ETH-in swap"))?;
+            }
+
+            if token_out_addr == Address::ZERO {
+                // Signer received amount_out and paid gas_cost, net change is amount_out - gas_cost.
+                amount_out = post
+                    .checked_sub(&pre)
+                    .ok_or_else(|| eyre::eyre!("ETH balance decreased unexpectedly on ETH-out swap"))?
+                    .checked_add(&gas_cost_eth)
+                    .ok_or_else(|| eyre::eyre!("overflow computing ETH amount_out"))?;
+            }
         }
 
         for log in receipt.logs() {
@@ -85,11 +125,6 @@ impl Swap {
             }
         }
 
-        let gas_units = BigUint::from(receipt.gas_used);
-        let wei_per_gas = BigUint::from(receipt.effective_gas_price);
-        // cost in wei, e.g. 5 × 10^14 wei = 500,000 Gwei ~ 0.0005 ETH
-        let gas_cost_eth = gas_units * wei_per_gas;
-
         Ok(Swap {
             token_in: swap.token_in,
             amount_in,

crates/core/src/trade.rs

@@ -160,7 +160,38 @@ impl Trade {
             }));
         }
 
-        let realized_profit = self.calculate_realized_profit(&slow_receipt, &fast_receipt)?;
+        let slow_provider = alloy::providers::ProviderBuilder::new()
+            .connect_http(
+                self.signal
+                    .slow_chain
+                    .rpc_url
+                    .parse()
+                    .wrap_err("invalid slow chain RPC URL")?,
+            );
+        let fast_provider = alloy::providers::ProviderBuilder::new()
+            .connect_http(
+                self.signal
+                    .fast_chain
+                    .rpc_url
+                    .parse()
+                    .wrap_err("invalid fast chain RPC URL")?,
+            );
+        let slow_swap = state::swap::Swap::try_from_receipts(
+            &slow_receipt,
+            self.signal.slow_swap_sim.clone(),
+            &slow_provider,
+        )
+        .await
+        .wrap_err("failed to parse slow swap from receipt")?;
+        let fast_swap = state::swap::Swap::try_from_receipts(
+            &fast_receipt,
+            self.signal.fast_swap_sim.clone(),
+            &fast_provider,
+        )
+        .await
+        .wrap_err("failed to parse fast swap from receipt")?;
+
+        let realized_profit = self.calculate_realized_profit(&slow_swap, &fast_swap)?;
 
         Ok(TradeResult::Successful(TradeSuccess {
             signal: self.signal,
@@ -180,16 +211,9 @@ impl Trade {
 
     fn calculate_realized_profit(
         &self,
-        slow_receipt: &TransactionReceipt,
-        fast_receipt: &TransactionReceipt,
+        slow_swap: &state::Swap,
+        fast_swap: &state::Swap,
     ) -> eyre::Result<RealizedProfit> {
-        let slow_swap =
-            state::swap::Swap::try_from_receipts(slow_receipt, self.signal.slow_swap_sim.clone())
-                .wrap_err("failed to parse slow swap from receipt")?;
-        let fast_swap =
-            state::swap::Swap::try_from_receipts(fast_receipt, self.signal.fast_swap_sim.clone())
-                .wrap_err("failed to parse fast swap from receipt")?;
-
         let profit = RealizedProfit::try_from_swaps(
             &slow_swap,
             &fast_swap,