fix(fortuna): Eip1559 fixes (#1597)

* fix(fortuna): Change order of middlewares to avoid calling gas oracle if legacy tx

* Auto detect EIP 1559

* Fault tolerant start of api and keeper

* Bump

apps/fortuna/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name    = "fortuna"
-version = "5.4.0"
+version = "5.4.1"
 edition = "2021"
 
 [dependencies]

apps/fortuna/src/chain/ethereum.rs

@@ -67,12 +67,12 @@ abigen!(
 );
 
 pub type SignablePythContract = PythRandom<
-    GasOracleMiddleware<
-        TransformerMiddleware<
+    TransformerMiddleware<
+        GasOracleMiddleware<
             NonceManagerMiddleware<SignerMiddleware<Provider<Http>, LocalWallet>>,
-            LegacyTxTransformer,
+            EthProviderOracle<Provider<Http>>,
         >,
-        EthProviderOracle<Provider<Http>>,
+        LegacyTxTransformer,
     >,
 >;
 pub type PythContract = PythRandom<Provider<Http>>;
@@ -102,11 +102,15 @@ impl SignablePythContract {
     ) -> Result<SignablePythContract> {
         let provider = Provider::<Http>::try_from(&chain_config.geth_rpc_addr)?;
         let chain_id = provider.get_chainid().await?;
-
+        let eip1559_supported = provider
+            .get_block(ethers::prelude::BlockNumber::Latest)
+            .await?
+            .ok_or_else(|| anyhow!("Latest block not found"))?
+            .base_fee_per_gas
+            .is_some();
         let gas_oracle = EthProviderOracle::new(provider.clone());
-
         let transformer = LegacyTxTransformer {
-            use_legacy_tx: chain_config.legacy_tx,
+            use_legacy_tx: !eip1559_supported,
         };
 
         let wallet__ = private_key
@@ -117,12 +121,12 @@ impl SignablePythContract {
 
         Ok(PythRandom::new(
             chain_config.contract_addr,
-            Arc::new(GasOracleMiddleware::new(
-                TransformerMiddleware::new(
+            Arc::new(TransformerMiddleware::new(
+                GasOracleMiddleware::new(
                     NonceManagerMiddleware::new(SignerMiddleware::new(provider, wallet__), address),
-                    transformer,
+                    gas_oracle,
                 ),
-                gas_oracle,
+                transformer,
             )),
         ))
     }

apps/fortuna/src/command/run.rs

@@ -10,6 +10,7 @@ use {
         config::{
             Commitment,
             Config,
+            EthereumConfig,
             ProviderConfig,
             RunOptions,
         },
@@ -149,77 +150,23 @@ pub async fn run_keeper(
 
 pub async fn run(opts: &RunOptions) -> Result<()> {
     let config = Config::load(&opts.config.config)?;
-    let provider_config = ProviderConfig::load(&opts.provider_config.provider_config)?;
     let secret = opts.randomness.load_secret()?;
     let (tx_exit, rx_exit) = watch::channel(false);
 
     let mut chains: HashMap<ChainId, BlockchainState> = HashMap::new();
     for (chain_id, chain_config) in &config.chains {
-        let contract = Arc::new(PythContract::from_config(&chain_config)?);
-        let provider_chain_config = provider_config.get_chain_config(chain_id)?;
-        let mut provider_commitments = provider_chain_config.get_sorted_commitments();
-        let provider_info = contract.get_provider_info(opts.provider).call().await?;
-        let latest_metadata =
-            bincode::deserialize::<CommitmentMetadata>(&provider_info.commitment_metadata)
-                .map_err(|e| {
-                    anyhow!(
-                        "Chain: {} - Failed to deserialize commitment metadata: {}",
-                        &chain_id,
-                        e
-                    )
-                })?;
-
-        provider_commitments.push(Commitment {
-            seed:                                latest_metadata.seed,
-            chain_length:                        latest_metadata.chain_length,
-            original_commitment_sequence_number: provider_info.original_commitment_sequence_number,
-        });
-
-        // TODO: we may want to load the hash chain in a lazy/fault-tolerant way. If there are many blockchains,
-        // then it's more likely that some RPC fails. We should tolerate these faults and generate the hash chain
-        // later when a user request comes in for that chain.
-
-        let mut offsets = Vec::<usize>::new();
-        let mut hash_chains = Vec::<PebbleHashChain>::new();
-
-        for commitment in &provider_commitments {
-            let offset = commitment.original_commitment_sequence_number.try_into()?;
-            offsets.push(offset);
-
-            let pebble_hash_chain = PebbleHashChain::from_config(
-                &secret,
-                &chain_id,
-                &opts.provider,
-                &chain_config.contract_addr,
-                &commitment.seed,
-                commitment.chain_length,
-            )?;
-            hash_chains.push(pebble_hash_chain);
-        }
-
-        let chain_state = HashChainState {
-            offsets,
-            hash_chains,
-        };
-
-        if chain_state.reveal(provider_info.original_commitment_sequence_number)?
-            != provider_info.original_commitment
-        {
-            return Err(anyhow!("The root of the generated hash chain for chain id {} does not match the commitment. Are the secret and chain length configured correctly?", &chain_id).into());
-        } else {
-            tracing::info!("Root of chain id {} matches commitment", &chain_id);
+        let state = setup_chain_state(&opts, &secret, chain_id, chain_config).await;
+        match state {
+            Ok(state) => {
+                chains.insert(chain_id.clone(), state);
+            }
+            Err(e) => {
+                tracing::error!("Failed to setup {} {}", chain_id, e);
+            }
         }
-
-        let state = api::BlockchainState {
-            id: chain_id.clone(),
-            state: Arc::new(chain_state),
-            contract,
-            provider_address: opts.provider,
-            reveal_delay_blocks: chain_config.reveal_delay_blocks,
-            confirmed_block_status: chain_config.confirmed_block_status,
-        };
-
-        chains.insert(chain_id.clone(), state);
+    }
+    if chains.is_empty() {
+        return Err(anyhow!("No chains were successfully setup"));
     }
 
 
@@ -254,6 +201,80 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
     Ok(())
 }
 
+async fn setup_chain_state(
+    opts: &&RunOptions,
+    secret: &String,
+    chain_id: &ChainId,
+    chain_config: &EthereumConfig,
+) -> Result<BlockchainState> {
+    let provider_config = ProviderConfig::load(&opts.provider_config.provider_config)?;
+    let contract = Arc::new(PythContract::from_config(&chain_config)?);
+    let provider_chain_config = provider_config.get_chain_config(chain_id)?;
+    let mut provider_commitments = provider_chain_config.get_sorted_commitments();
+    let provider_info = contract.get_provider_info(opts.provider).call().await?;
+    let latest_metadata = bincode::deserialize::<CommitmentMetadata>(
+        &provider_info.commitment_metadata,
+    )
+    .map_err(|e| {
+        anyhow!(
+            "Chain: {} - Failed to deserialize commitment metadata: {}",
+            &chain_id,
+            e
+        )
+    })?;
+
+    provider_commitments.push(Commitment {
+        seed:                                latest_metadata.seed,
+        chain_length:                        latest_metadata.chain_length,
+        original_commitment_sequence_number: provider_info.original_commitment_sequence_number,
+    });
+
+    // TODO: we may want to load the hash chain in a lazy/fault-tolerant way. If there are many blockchains,
+    // then it's more likely that some RPC fails. We should tolerate these faults and generate the hash chain
+    // later when a user request comes in for that chain.
+
+    let mut offsets = Vec::<usize>::new();
+    let mut hash_chains = Vec::<PebbleHashChain>::new();
+
+    for commitment in &provider_commitments {
+        let offset = commitment.original_commitment_sequence_number.try_into()?;
+        offsets.push(offset);
+
+        let pebble_hash_chain = PebbleHashChain::from_config(
+            &secret,
+            &chain_id,
+            &opts.provider,
+            &chain_config.contract_addr,
+            &commitment.seed,
+            commitment.chain_length,
+        )?;
+        hash_chains.push(pebble_hash_chain);
+    }
+
+    let chain_state = HashChainState {
+        offsets,
+        hash_chains,
+    };
+
+    if chain_state.reveal(provider_info.original_commitment_sequence_number)?
+        != provider_info.original_commitment
+    {
+        return Err(anyhow!("The root of the generated hash chain for chain id {} does not match the commitment. Are the secret and chain length configured correctly?", &chain_id).into());
+    } else {
+        tracing::info!("Root of chain id {} matches commitment", &chain_id);
+    }
+
+    let state = BlockchainState {
+        id: chain_id.clone(),
+        state: Arc::new(chain_state),
+        contract,
+        provider_address: opts.provider,
+        reveal_delay_blocks: chain_config.reveal_delay_blocks,
+        confirmed_block_status: chain_config.confirmed_block_status,
+    };
+    Ok(state)
+}
+
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, EncodeLabelSet)]
 pub struct ChainLabel {

apps/fortuna/src/config.rs

@@ -148,10 +148,6 @@ pub struct EthereumConfig {
     /// its commitment.
     pub reveal_delay_blocks: BlockNumber,
 
-    /// Use the legacy transaction format (for networks without EIP 1559)
-    #[serde(default)]
-    pub legacy_tx: bool,
-
     /// The BlockStatus of the block that is considered confirmed.
     /// For example, Finalized, Safe, Latest
     #[serde(default)]