fix(txn-sender): use a WS provider instead of HTTP

fhevm-engine/fhevm-listener/.gitignore

@@ -0,0 +1,2 @@
+artifacts
+cache

fhevm-engine/fhevm-listener/Cargo.toml

@@ -34,3 +34,4 @@ serial_test = "3.2.0"
 
 [build-dependencies]
 foundry-compilers = { version = "0.13.0", features = ["svm-solc"] }
+semver = "1.0.26"

fhevm-engine/fhevm-listener/build.rs

@@ -1,13 +1,23 @@
-use foundry_compilers::{Project, ProjectPathsConfig};
+use foundry_compilers::{
+    multi::MultiCompiler,
+    solc::{Solc, SolcCompiler},
+    Project, ProjectPathsConfig,
+};
+use semver::Version;
 use std::path::Path;
 fn main() {
     println!("cargo::warning=build.rs run ...");
     let paths =
         ProjectPathsConfig::hardhat(Path::new(env!("CARGO_MANIFEST_DIR")))
             .unwrap();
+    // Use a specific version due to an issue with libc and libstdc++ in the rust Docker image we use to run it.
+    let solc = Solc::find_or_install(&Version::new(0, 8, 28)).unwrap();
     let project = Project::builder()
         .paths(paths)
-        .build(Default::default())
+        .build(
+            MultiCompiler::new(Some(SolcCompiler::Specific(solc)), None)
+                .unwrap(),
+        )
         .unwrap();
     let output = project.compile().unwrap();
     if output.has_compiler_errors() {

fhevm-engine/gw-listener/src/bin/gw_listener.rs

@@ -57,8 +57,7 @@ async fn main() -> anyhow::Result<()> {
 
     let provider = ProviderBuilder::new()
         .on_ws(WsConnect::new(conf.gw_url.clone()))
-        .await
-        .expect("should have valid provider");
+        .await?;
 
     let cancel_token = CancellationToken::new();
     let gw_listener = GatewayListener::new(

fhevm-engine/transaction-sender/src/bin/transaction_sender.rs

@@ -1,8 +1,11 @@
 use std::str::FromStr;
 
 use alloy::{
-    network::EthereumWallet, primitives::Address, providers::ProviderBuilder,
-    signers::local::PrivateKeySigner, transports::http::reqwest::Url,
+    network::EthereumWallet,
+    primitives::Address,
+    providers::{ProviderBuilder, WsConnect},
+    signers::local::PrivateKeySigner,
+    transports::http::reqwest::Url,
 };
 use clap::Parser;
 use tokio::signal::unix::{signal, SignalKind};
@@ -100,10 +103,11 @@ async fn main() -> anyhow::Result<()> {
         .clone()
         .unwrap_or_else(|| std::env::var("DATABASE_URL").expect("DATABASE_URL is undefined"));
     let cancel_token = CancellationToken::new();
-    let provider = ProviderBuilder::new()
-        .filler(ProviderFillers::default())
+    let provider = ProviderBuilder::default()
         .wallet(wallet)
-        .on_http(conf.gateway_url);
+        .filler(ProviderFillers::default())
+        .on_ws(WsConnect::new(conf.gateway_url))
+        .await?;
     let sender = TransactionSender::new(
         conf.zkpok_manager_address,
         conf.ciphertext_manager_address,

fhevm-engine/transaction-sender/tests/add_ciphertext_tests.rs

@@ -1,4 +1,4 @@
-use alloy::providers::{Provider, ProviderBuilder, WalletProvider};
+use alloy::providers::{Provider, ProviderBuilder, WsConnect};
 use alloy::signers::local::PrivateKeySigner;
 use common::{CiphertextManager, TestEnvironment};
 
@@ -17,8 +17,10 @@ mod common;
 async fn test_add_ciphertext_digests() -> anyhow::Result<()> {
     let env = TestEnvironment::new().await?;
     let provider = ProviderBuilder::default()
+        .wallet(env.wallet)
         .filler(ProviderFillers::default())
-        .on_anvil_with_wallet();
+        .on_ws(WsConnect::new(env.anvil.ws_endpoint_url()))
+        .await?;
 
     let ciphertext_manager = CiphertextManager::deploy(&provider).await?;
     let txn_sender = TransactionSender::new(
@@ -40,9 +42,7 @@ async fn test_add_ciphertext_digests() -> anyhow::Result<()> {
     //  Add a ciphertext digest to database
     let handle = random::<[u8; 32]>().to_vec();
     // Record initial transaction count.
-    let initial_tx_count = provider
-        .get_transaction_count(provider.default_signer_address())
-        .await?;
+    let initial_tx_count = provider.get_transaction_count(env.signer.address()).await?;
 
     // Insert a ciphertext digest into the database.
     insert_ciphertext_digest(
@@ -95,9 +95,7 @@ async fn test_add_ciphertext_digests() -> anyhow::Result<()> {
     );
 
     // Verify that a transaction has been sent.
-    let tx_count = provider
-        .get_transaction_count(provider.default_signer_address())
-        .await?;
+    let tx_count = provider.get_transaction_count(env.signer.address()).await?;
     assert_eq!(
         tx_count,
         initial_tx_count + 1,
@@ -122,7 +120,8 @@ async fn test_retry_mechanism() -> anyhow::Result<()> {
     // Create a provider without a wallet.
     let provider = ProviderBuilder::default()
         .filler(ProviderFillers::default())
-        .on_anvil();
+        .on_ws(WsConnect::new(env.anvil.ws_endpoint_url()))
+        .await?;
     let txn_sender = TransactionSender::new(
         PrivateKeySigner::random().address(),
         PrivateKeySigner::random().address(),

fhevm-engine/transaction-sender/tests/allow_handle.rs

@@ -1,6 +1,6 @@
-use alloy::primitives::Address;
 use alloy::providers::ProviderBuilder;
 use alloy::signers::local::PrivateKeySigner;
+use alloy::{primitives::Address, providers::WsConnect};
 use common::{ACLManager, TestEnvironment};
 
 use rand::random;
@@ -18,8 +18,10 @@ mod common;
 async fn test_allow_handle() -> anyhow::Result<()> {
     let env = TestEnvironment::new().await?;
     let provider = ProviderBuilder::default()
+        .wallet(env.wallet)
         .filler(ProviderFillers::default())
-        .on_anvil_with_wallet();
+        .on_ws(WsConnect::new(env.anvil.ws_endpoint_url()))
+        .await?;
     let acl_manager = ACLManager::deploy(&provider).await?;
 
     let txn_sender = TransactionSender::new(

fhevm-engine/transaction-sender/tests/common.rs

@@ -1,4 +1,10 @@
-use alloy::{primitives::Address, signers::local::PrivateKeySigner, sol};
+use alloy::{
+    network::EthereumWallet,
+    node_bindings::{Anvil, AnvilInstance},
+    primitives::Address,
+    signers::local::PrivateKeySigner,
+    sol,
+};
 use sqlx::{postgres::PgPoolOptions, Pool, Postgres};
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
@@ -31,6 +37,10 @@ pub struct TestEnvironment {
     pub contract_address: Address,
     #[allow(dead_code)]
     pub user_address: Address,
+    #[allow(dead_code)]
+    pub anvil: AnvilInstance,
+    #[allow(dead_code)]
+    pub wallet: EthereumWallet,
 }
 
 impl TestEnvironment {
@@ -57,13 +67,18 @@ impl TestEnvironment {
         )
         .await?;
 
+        let anvil = Anvil::new().try_spawn()?;
+        let signer: PrivateKeySigner = anvil.keys()[0].clone().into();
+        let wallet = signer.clone().into();
         Ok(Self {
-            signer: PrivateKeySigner::random(),
+            signer,
             conf,
             cancel_token: CancellationToken::new(),
             db_pool,
             contract_address: PrivateKeySigner::random().address(),
             user_address: PrivateKeySigner::random().address(),
+            anvil,
+            wallet,
         })
     }
 }