Migrate BalancerV2Vault to alloy (cowprotocol#3793)

Author: xdecentralix

crates/autopilot/src/run.rs

@@ -26,7 +26,7 @@ use {
     },
     chain::Chain,
     clap::Parser,
-    contracts::{BalancerV2Vault, IUniswapV3Factory},
+    contracts::{IUniswapV3Factory, alloy::BalancerV2Vault},
     ethcontract::{BlockNumber, H160, common::DeploymentInformation, errors::DeployError},
     ethrpc::{
         Web3,
@@ -232,22 +232,21 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         .instrument(info_span!("vault_relayer_call"))
         .await
         .expect("Couldn't get vault relayer address");
-    let vault = match args.shared.balancer_v2_vault_address {
-        Some(address) => Some(contracts::BalancerV2Vault::with_deployment_info(
-            &web3, address, None,
-        )),
-        None => match BalancerV2Vault::deployed(&web3)
-            .instrument(info_span!("balancerV2vault_deployed"))
-            .await
-        {
-            Ok(contract) => Some(contract),
-            Err(DeployError::NotFound(_)) => {
-                tracing::warn!("balancer contracts are not deployed on this network");
-                None
-            }
-            Err(err) => panic!("failed to get balancer vault contract: {err}"),
-        },
-    };
+
+    let vault_address = args.shared.balancer_v2_vault_address.or_else(|| {
+        let chain_id = chain.id();
+        let addr = BalancerV2Vault::deployment_address(&chain_id);
+        if addr.is_none() {
+            tracing::warn!(
+                chain_id,
+                "balancer contracts are not deployed on this network"
+            );
+        }
+        addr
+    });
+    let vault =
+        vault_address.map(|address| BalancerV2Vault::Instance::new(address, web3.alloy.clone()));
+
     let uniswapv3_factory = match IUniswapV3Factory::deployed(&web3)
         .instrument(info_span!("uniswapv3_deployed"))
         .await
@@ -275,7 +274,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
             eth.contracts().settlement().clone(),
             eth.contracts().balances().clone(),
             vault_relayer,
-            vault.as_ref().map(|contract| contract.address()),
+            vault_address.map(IntoLegacy::into_legacy),
             balance_overrider,
         ),
         eth.current_block().clone(),

crates/balancer-solver/src/domain/solver.rs

@@ -147,7 +147,10 @@ impl Solver {
             (Some(vault_addr), Some(batch_router_addr), Some(ref node_url)) => {
                 let web3 =
                     ethrpc::web3(Default::default(), Default::default(), node_url, "verifier");
-                let vault = contracts::BalancerV2Vault::at(&web3, vault_addr.0);
+                let vault = contracts::alloy::BalancerV2Vault::Instance::new(
+                    vault_addr.0.into_alloy(),
+                    web3.alloy.clone(),
+                );
                 let batch_router = contracts::alloy::BalancerV3BatchRouter::Instance::new(
                     batch_router_addr.0.into_alloy(),
                     web3.alloy,

crates/balancer-solver/src/infra/solution_verifier.rs

@@ -1,13 +1,13 @@
 use {
     alloy::primitives,
-    contracts::{
-        BalancerV2Vault,
-        alloy::BalancerV3BatchRouter::{
+    contracts::alloy::{
+        BalancerV2Vault::{self, IVault},
+        BalancerV3BatchRouter::{
             self,
             IBatchRouter::{SwapPathExactAmountIn, SwapPathStep},
         },
     },
-    ethcontract::{Address, Bytes, H160, U256},
+    ethcontract::{Address, H160, U256},
     ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     serde::{Deserialize, Serialize},
 };
@@ -52,12 +52,15 @@ pub enum PoolVersion {
 
 #[derive(Clone)]
 pub struct SolutionVerifier {
-    vault: BalancerV2Vault,
+    vault: BalancerV2Vault::Instance,
     batch_router: BalancerV3BatchRouter::Instance,
 }
 
 impl SolutionVerifier {
-    pub fn new(vault: BalancerV2Vault, batch_router: BalancerV3BatchRouter::Instance) -> Self {
+    pub fn new(
+        vault: BalancerV2Vault::Instance,
+        batch_router: BalancerV3BatchRouter::Instance,
+    ) -> Self {
         Self {
             vault,
             batch_router,
@@ -216,6 +219,7 @@ impl SolutionVerifier {
     }
 
     /// Quote V2 swap via Vault.queryBatchSwap
+    /// This uses a static call (eth_call) to query the expected output amount.
     async fn quote_v2_swap(
         &self,
         balancer_pool_id: &str,
@@ -237,35 +241,36 @@ impl SolutionVerifier {
         let mut pool_id = [0u8; 32];
         pool_id.copy_from_slice(&pool_id_bytes);
 
-        // Build assets array: [token_in, token_out]
-        let assets = vec![input_token, output_token];
-
-        // Create BatchSwapStep
-        let swap = self.vault.methods().query_batch_swap(
-            0u8.into(), // SwapKind.GIVEN_IN
-            vec![(
-                Bytes(pool_id),
-                0u64.into(), // assetInIndex
-                1u64.into(), // assetOutIndex
-                input_amount,
-                Bytes(vec![]), // empty userData
-            )],
+        // Build assets array using alloy types
+        let assets = vec![input_token.into_alloy(), output_token.into_alloy()];
+
+        // Create BatchSwapStep using alloy types
+        let swap_step = IVault::BatchSwapStep {
+            poolId: primitives::FixedBytes::from(pool_id),
+            assetInIndex: primitives::U256::from(0u64),
+            assetOutIndex: primitives::U256::from(1u64),
+            amount: input_amount.into_alloy(),
+            userData: primitives::Bytes::new(),
+        };
+
+        // Create FundManagement struct
+        let funds = IVault::FundManagement {
+            sender: primitives::Address::ZERO,
+            fromInternalBalance: false,
+            recipient: primitives::Address::ZERO,
+            toInternalBalance: false,
+        };
+
+        // Build the call - .call() automatically makes it a static call (eth_call)
+        let call_builder = self.vault.queryBatchSwap(
+            0u8, // SwapKind.GIVEN_IN
+            vec![swap_step.clone()],
             assets.clone(),
-            (
-                H160::zero(), // sender (not needed for query)
-                false,        // fromInternalBalance
-                H160::zero(), // recipient (not needed for query)
-                false,        // toInternalBalance
-            ),
+            funds,
         );
 
         // Capture contract call details for debugging
-        let calldata = swap
-            .tx
-            .data
-            .clone()
-            .map(|d| format!("0x{}", hex::encode(d.0)))
-            .unwrap_or_else(|| "0x".to_string());
+        let calldata = format!("0x{}", hex::encode(call_builder.calldata()));
 
         let decoded_params = serde_json::json!({
             "kind": "GIVEN_IN (0)",
@@ -277,8 +282,8 @@ impl SolutionVerifier {
                 "userData": "0x"
             }],
             "assets": vec![
-                format!("{:?}", assets[0]),
-                format!("{:?}", assets[1])
+                format!("{:?}", input_token),
+                format!("{:?}", output_token)
             ],
             "funds": {
                 "sender": "0x0000000000000000000000000000000000000000",
@@ -289,34 +294,47 @@ impl SolutionVerifier {
         });
 
         let call_details = ContractCallDetails {
-            contract_address: format!("{:?}", self.vault.address()),
+            contract_address: format!("{:?}", self.vault.address().into_legacy()),
             contract_name: "BalancerV2Vault".to_string(),
             function_name: "queryBatchSwap".to_string(),
             calldata,
             decoded_params,
         };
 
-        // Call the query (static call)
-        let deltas = swap.call().await?;
+        // Execute the static call
+        let result = call_builder.call().await;
 
-        // Parse output: assetDeltas[1] represents net token flow for output token
-        // In Balancer V2:
-        //   - Positive delta = tokens going INTO vault (user sends)
-        //   - Negative delta = tokens coming OUT of vault (user receives)
-        // For the output token in a swap, we expect a NEGATIVE delta
-        if deltas.len() < 2 {
-            return Err("Invalid deltas returned from queryBatchSwap".into());
-        }
+        match result {
+            Ok(deltas) => {
+                // Parse output: assetDeltas[1] represents net token flow for output token
+                // In Balancer V2:
+                //   - Positive delta = tokens going INTO vault (user sends)
+                //   - Negative delta = tokens coming OUT of vault (user receives)
+                // For the output token in a swap, we expect a NEGATIVE delta
+                if deltas.len() < 2 {
+                    return Err("Invalid deltas returned from queryBatchSwap".into());
+                }
 
-        let amount_out = if deltas[1].is_negative() {
-            // Negative means tokens out - negate to get positive amount
-            (-deltas[1]).into_raw()
-        } else {
-            // Positive means tokens in, which is wrong for output token
-            return Err("Expected negative output delta (tokens out of vault)".into());
-        };
+                let delta_out = deltas[1];
+
+                // Check if the signed value is negative
+                let amount_out = if delta_out.is_negative() {
+                    // Negative means tokens out - convert to unsigned by negating
+                    // For Signed types, we need to negate and convert to unsigned
+                    let abs_value = delta_out.abs();
+                    primitives::U256::from_limbs(abs_value.into_limbs())
+                } else {
+                    // Positive means tokens in, which is wrong for output token
+                    return Err("Expected negative output delta (tokens out of vault)".into());
+                };
 
-        Ok((amount_out.to_string(), call_details))
+                Ok((amount_out.to_string(), call_details))
+            }
+            Err(e) => {
+                // Return the error - call details will be saved separately in the JSON
+                Err(format!("Query failed: {:?}", e).into())
+            }
+        }
     }
 
     /// Quote V3 swap via Batch Router.querySwapExactIn

crates/contracts/build.rs

@@ -31,86 +31,6 @@ fn main() {
     // - https://doc.rust-lang.org/cargo/reference/build-scripts.html#cargorerun-if-changedpath
     println!("cargo:rerun-if-changed=build.rs");
 
-    // Balancer addresses can be obtained from:
-    // <https://github.com/balancer/balancer-subgraph-v2/blob/master/networks.yaml>
-    generate_contract_with_config("BalancerV2Vault", |builder| {
-        builder
-            .contract_mod_override("balancer_v2_vault")
-            .add_network(
-                MAINNET,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://etherscan.io/tx/0x28c44bb10d469cbd42accf97bd00b73eabbace138e9d44593e851231fbed1cb7>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(12272146)),
-                },
-            )
-            .add_network(
-                GNOSIS,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://gnosisscan.io/tx/0x21947751661e1b9197492f22779af1f5175b71dc7057869e5a8593141d40edf1>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(24821598)),
-                },
-            )
-            .add_network(
-                SEPOLIA,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://sepolia.etherscan.io/tx/0xb22509c6725dd69a975ecb96a0c594901eeee6a279cc66d9d5191022a7039ee6>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(3418831)),
-                },
-            )
-            .add_network(
-                ARBITRUM_ONE,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://arbiscan.io/tx/0xe2c3826bd7b15ef8d338038769fe6140a44f1957a36b0f27ab321ab6c68d5a8e>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(222832)),
-                },
-            )
-            .add_network(
-                BASE,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://basescan.org/tx/0x0dc2e3d436424f2f038774805116896d31828c0bf3795a6901337bdec4e0dff6>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(1196036)),
-                },
-            )
-            .add_network(
-                AVALANCHE,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://snowscan.xyz/tx/0xc49af0372feb032e0edbba6988410304566b1fd65546c01ced620ac3c934120f>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(26386141)),
-                },
-            )
-            .add_network(
-                BNB,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://bscscan.com/tx/0x1de8caa6c54ff9a25600e26d80865d84c9cc4d33c2b98611240529ee7de5cd74>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(22691002)),
-                },
-            )
-            .add_network(
-                OPTIMISM,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://optimistic.etherscan.io/tx/0xa03cb990595df9eed6c5db17a09468cab534aed5f5589a06c0bb3d19dd2f7ce9>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(7003431)),
-                },
-            )
-            .add_network(
-                POLYGON,
-                Network {
-                    address: addr("0xBA12222222228d8Ba445958a75a0704d566BF2C8"),
-                    // <https://polygonscan.com/tx/0x66f275a2ed102a5b679c0894ced62c4ebcb2a65336d086a916eb83bd1fe5c8d2>
-                    deployment_information: Some(DeploymentInformation::BlockNumber(15832990)),
-                },
-            )
-        // Not available on Lens
-    });
-
     // Balancer V3 contracts
     generate_contract_with_config("BalancerV3Vault", |builder| {
         builder

crates/contracts/src/alloy.rs

@@ -349,6 +349,8 @@ crate::bindings!(
     }
 );
 crate::bindings!(
+    // Balancer addresses can be obtained from:
+    // <https://github.com/balancer/balancer-subgraph-v2/blob/master/networks.yaml>
     BalancerV2Vault,
     crate::deployments! {
         // <https://etherscan.io/tx/0x28c44bb10d469cbd42accf97bd00b73eabbace138e9d44593e851231fbed1cb7>

crates/contracts/src/lib.rs

@@ -49,7 +49,6 @@ macro_rules! include_contracts {
 }
 
 include_contracts! {
-    BalancerV2Vault;
     BalancerV3Vault;
     BalancerV3WeightedPool;
     BalancerV3WeightedPoolFactory;
@@ -164,7 +163,6 @@ mod tests {
         ] {
             assert_has_deployment_address!(GPv2Settlement for *network);
             assert_has_deployment_address!(WETH9 for *network);
-            assert_has_deployment_address!(BalancerV2Vault for *network);
             assert!(
                 alloy::BalancerV2NoProtocolFeeLiquidityBootstrappingPoolFactory::deployment_address(network).is_some()
             )
@@ -223,7 +221,6 @@ mod tests {
 
         for network in &[MAINNET, GNOSIS, SEPOLIA, ARBITRUM_ONE] {
             assert_has_deployment_information!(GPv2Settlement for *network);
-            assert_has_deployment_information!(BalancerV2Vault for *network);
         }
         assert!(alloy::BalancerV2WeightedPoolFactory::deployment_address(&MAINNET).is_some());
         for network in &[MAINNET, ARBITRUM_ONE] {