upgrading to use the new contract API

Author: jayantk

apps/fortuna/src/api/revelation.rs

@@ -45,7 +45,7 @@ pub async fn revelation(
         .get(&chain_id)
         .ok_or(RestError::InvalidChainId)?;
 
-    let maybe_request_fut = state.contract.get_request(state.provider_address, sequence);
+    let maybe_request_fut = state.contract.get_request_v2(state.provider_address, sequence);
 
     let current_block_number_fut = state
         .contract

apps/fortuna/src/chain/ethereum.rs

@@ -233,29 +233,21 @@ impl InstrumentedPythContract {
 
 #[async_trait]
 impl<T: JsonRpcClient + 'static> EntropyReader for PythRandom<Provider<T>> {
-    async fn get_request(
+    async fn get_request_v2(
         &self,
         provider_address: Address,
         sequence_number: u64,
     ) -> Result<Option<reader::Request>> {
-        let r = self
-            .get_request(provider_address, sequence_number)
-            // TODO: This doesn't work for lighlink right now. Figure out how to do this in lightlink
-            // .block(ethers::core::types::BlockNumber::Finalized)
+        let request = self
+            .get_request_v2(provider_address, sequence_number)
             .call()
             .await?;
-
-        // sequence_number == 0 means the request does not exist.
-        if r.sequence_number != 0 {
-            Ok(Some(reader::Request {
-                provider: r.provider,
-                sequence_number: r.sequence_number,
-                block_number: r.block_number,
-                use_blockhash: r.use_blockhash,
-            }))
-        } else {
-            Ok(None)
-        }
+        Ok(Some(reader::Request {
+            provider: request.provider,
+            sequence_number: request.sequence_number,
+            block_number: request.block_number,
+            use_blockhash: request.use_blockhash,
+        }))
     }
 
     async fn get_block_number(&self, confirmed_block_status: BlockStatus) -> Result<BlockNumber> {

apps/fortuna/src/chain/reader.rs

@@ -42,7 +42,7 @@ pub trait EntropyReader: Send + Sync {
     /// Get an in-flight request (if it exists)
     /// Note that if we support additional blockchains in the future, the type of `provider` may
     /// need to become more generic.
-    async fn get_request(&self, provider: Address, sequence_number: u64)
+    async fn get_request_v2(&self, provider: Address, sequence_number: u64)
         -> Result<Option<Request>>;
 
     async fn get_block_number(&self, confirmed_block_status: BlockStatus) -> Result<BlockNumber>;
@@ -141,7 +141,7 @@ pub mod mock {
 
     #[async_trait]
     impl EntropyReader for MockEntropyReader {
-        async fn get_request(
+        async fn get_request_v2(
             &self,
             provider: Address,
             sequence_number: u64,

apps/fortuna/src/command/get_request.rs

@@ -14,12 +14,12 @@ pub async fn get_request(opts: &GetRequestOptions) -> Result<()> {
         &Config::load(&opts.config.config)?.get_chain_config(&opts.chain_id)?,
     )?);
 
-    let p = contract.get_provider_info(opts.provider).call().await?;
+    let p = contract.get_provider_info_v2(opts.provider).call().await?;
 
     tracing::info!("Found provider: {:?}", p);
 
     let r = contract
-        .get_request(opts.provider, opts.sequence)
+        .get_request_v2(opts.provider, opts.sequence)
         .call()
         .await?;
     tracing::info!("Found request: {:?}", r);

apps/fortuna/src/command/inspect.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        chain::ethereum::{EntropyStructsRequest, PythContract},
+        chain::ethereum::{EntropyStructsV2Request, PythContract},
         config::{Config, EthereumConfig, InspectOptions},
     },
     anyhow::Result,
@@ -43,7 +43,7 @@ async fn inspect_chain(
 
     let contract = PythContract::from_config(chain_config)?;
     let entropy_provider = contract.get_default_provider().call().await?;
-    let provider_info = contract.get_provider_info(entropy_provider).call().await?;
+    let provider_info = contract.get_provider_info_v2(entropy_provider).call().await?;
     let mut current_request_number = provider_info.sequence_number;
     println!("Initial request number: {}", current_request_number);
     let last_request_number = current_request_number.saturating_sub(num_requests);
@@ -61,12 +61,12 @@ async fn inspect_chain(
                     break;
                 }
                 multicall.add_call(
-                    contract.get_request(entropy_provider, current_request_number),
+                    contract.get_request_v2(entropy_provider, current_request_number),
                     false,
                 );
                 current_request_number -= 1;
             }
-            let return_data: Vec<EntropyStructsRequest> = multicall.call_array().await?;
+            let return_data: Vec<EntropyStructsV2Request> = multicall.call_array().await?;
             for request in return_data {
                 process_request(rpc_provider.clone(), request).await?;
             }
@@ -76,7 +76,7 @@ async fn inspect_chain(
         println!("Multicall not deployed in this chain, fetching requests one by one");
         while current_request_number > last_request_number {
             let request = contract
-                .get_request(entropy_provider, current_request_number)
+                .get_request_v2(entropy_provider, current_request_number)
                 .call()
                 .await?;
             process_request(rpc_provider.clone(), request).await?;
@@ -91,9 +91,9 @@ async fn inspect_chain(
 
 async fn process_request(
     rpc_provider: Provider<Http>,
-    request: EntropyStructsRequest,
+    request: EntropyStructsV2Request,
 ) -> Result<()> {
-    if request.sequence_number != 0 && request.is_request_with_callback {
+    if request.sequence_number != 0 && request.callback_status != 0 {
         let block = rpc_provider
             .get_block(request.block_number)
             .await?

apps/fortuna/src/command/run.rs

@@ -228,7 +228,7 @@ async fn setup_chain_state(
             .cmp(&c2.original_commitment_sequence_number)
     });
 
-    let provider_info = contract.get_provider_info(*provider).call().await?;
+    let provider_info = contract.get_provider_info_v2(*provider).call().await?;
     let latest_metadata = bincode::deserialize::<CommitmentMetadata>(
         &provider_info.commitment_metadata,
     )

apps/fortuna/src/command/setup_provider.rs

@@ -1,21 +1,15 @@
 use {
     crate::{
         api::{get_register_uri, ChainId},
-        chain::ethereum::{EntropyStructsProviderInfo, SignablePythContract},
+        chain::ethereum::{EntropyStructsV2ProviderInfo, SignablePythContract},
         command::register_provider::{register_provider_from_config, CommitmentMetadata},
         config::{Config, EthereumConfig, SetupProviderOptions},
         state::{HashChainState, PebbleHashChain},
-    },
-    anyhow::{anyhow, Result},
-    ethers::{
+    }, anyhow::{anyhow, Result}, ethers::{
         abi::Bytes as AbiBytes,
         signers::{LocalWallet, Signer},
         types::{Address, Bytes},
-    },
-    futures::future::join_all,
-    std::sync::Arc,
-    tokio::spawn,
-    tracing::Instrument,
+    }, futures::future::join_all, std::sync::Arc, tokio::spawn, tracing::Instrument
 };
 
 /// Setup provider for all the chains.
@@ -76,7 +70,7 @@ async fn setup_chain_provider(
     let contract = Arc::new(SignablePythContract::from_config(chain_config, &private_key).await?);
 
     tracing::info!("Fetching provider info");
-    let provider_info = contract.get_provider_info(provider_address).call().await?;
+    let provider_info = contract.get_provider_info_v2(provider_address).call().await?;
     tracing::info!("Provider info: {:?}", provider_info);
 
     let mut register = false;
@@ -146,7 +140,7 @@ async fn setup_chain_provider(
         tracing::info!("Registered");
     }
 
-    let provider_info = contract.get_provider_info(provider_address).call().await?;
+    let provider_info = contract.get_provider_info_v2(provider_address).call().await?;
 
     sync_fee(&contract, &provider_info, chain_config.fee)
         .in_current_span()
@@ -173,12 +167,20 @@ async fn setup_chain_provider(
     .in_current_span()
     .await?;
 
+    sync_default_gas_limit(
+        &contract,
+        &provider_info,
+        chain_config.gas_limit,
+    )
+    .in_current_span()
+    .await?;
+
     Ok(())
 }
 
 async fn sync_uri(
     contract: &Arc<SignablePythContract>,
-    provider_info: &EntropyStructsProviderInfo,
+    provider_info: &EntropyStructsV2ProviderInfo,
     uri: String,
 ) -> Result<()> {
     let uri_as_bytes: Bytes = AbiBytes::from(uri.as_str()).into();
@@ -198,7 +200,7 @@ async fn sync_uri(
 
 async fn sync_fee(
     contract: &Arc<SignablePythContract>,
-    provider_info: &EntropyStructsProviderInfo,
+    provider_info: &EntropyStructsV2ProviderInfo,
     provider_fee: u128,
 ) -> Result<()> {
     if provider_info.fee_in_wei != provider_fee {
@@ -217,7 +219,7 @@ async fn sync_fee(
 
 async fn sync_fee_manager(
     contract: &Arc<SignablePythContract>,
-    provider_info: &EntropyStructsProviderInfo,
+    provider_info: &EntropyStructsV2ProviderInfo,
     fee_manager: Address,
 ) -> Result<()> {
     if provider_info.fee_manager != fee_manager {
@@ -231,7 +233,7 @@ async fn sync_fee_manager(
 
 async fn sync_max_num_hashes(
     contract: &Arc<SignablePythContract>,
-    provider_info: &EntropyStructsProviderInfo,
+    provider_info: &EntropyStructsV2ProviderInfo,
     max_num_hashes: u32,
 ) -> Result<()> {
     if provider_info.max_num_hashes != max_num_hashes {
@@ -247,3 +249,22 @@ async fn sync_max_num_hashes(
     }
     Ok(())
 }
+
+async fn sync_default_gas_limit(
+    contract: &Arc<SignablePythContract>,
+    provider_info: &EntropyStructsV2ProviderInfo,
+    default_gas_limit: u32,
+) -> Result<()> {
+    if provider_info.default_gas_limit != default_gas_limit {
+        tracing::info!("Updating provider default gas limit to {:?}", default_gas_limit);
+        if let Some(receipt) = contract
+            .set_default_gas_limit(default_gas_limit)
+            .send()
+            .await?
+            .await?
+        {
+            tracing::info!("Updated provider default gas limit to : {:?}", receipt);
+        }
+    }
+    Ok(())
+}

apps/fortuna/src/command/withdraw_fees.rs

@@ -58,7 +58,7 @@ pub async fn withdraw_fees_for_chain(
     retained_balance: u128,
 ) -> Result<()> {
     tracing::info!("Fetching fees for provider: {:?}", provider_address);
-    let provider_info = contract.get_provider_info(provider_address).call().await?;
+    let provider_info = contract.get_provider_info_v2(provider_address).call().await?;
     let fees = provider_info.accrued_fees_in_wei;
     tracing::info!("Accrued fees: {} wei", fees);
 

apps/fortuna/src/config.rs

@@ -136,7 +136,7 @@ pub struct EthereumConfig {
     pub legacy_tx: bool,
 
     /// The gas limit to use for entropy callback transactions.
-    pub gas_limit: u64,
+    pub gas_limit: u32,
 
     /// The percentage multiplier to apply to priority fee estimates (100 = no change, e.g. 150 = 150% of base fee)
     #[serde(default = "default_priority_fee_multiplier_pct")]

apps/fortuna/src/keeper.rs

@@ -150,7 +150,7 @@ pub async fn run_keeper_threads(
             // near the maximum gas limit.
             // In the unlikely event that the keeper fees aren't sufficient, the solution to this is to configure the target
             // fee percentage to be higher on that specific chain.
-            chain_eth_config.gas_limit,
+            chain_eth_config.gas_limit.into(),
             // NOTE: unwrap() here so we panic early if someone configures these values below -100.
             u64::try_from(100 + chain_eth_config.min_profit_pct)
                 .expect("min_profit_pct must be >= -100"),