feat(fortuna): Support new Entropy v2 contract

apps/fortuna/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "7.5.3"
+version = "8.0.0"
 edition = "2021"
 
 [lib]

apps/fortuna/src/api/revelation.rs

@@ -88,7 +88,9 @@ pub async fn revelation(
                 .ok_or(RestError::NoPendingRequest)?;
         }
         None => {
-            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 (maybe_request, current_block_number) =
                 try_join!(maybe_request_fut, current_block_number_fut).map_err(|e| {
                     tracing::error!(chain_id = chain_id, "RPC request failed {}", e);

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,8 +42,11 @@ 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)
-        -> Result<Option<Request>>;
+    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>;
 
@@ -142,7 +145,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,10 @@ 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 +64,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 +79,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 +94,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

@@ -205,7 +205,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,7 +1,7 @@
 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},
@@ -76,7 +76,10 @@ 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;
@@ -147,7 +150,10 @@ 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()
@@ -174,12 +180,16 @@ 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();
@@ -199,7 +209,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 {
@@ -218,7 +228,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 {
@@ -232,7 +242,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 {
@@ -248,3 +258,25 @@ 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,10 @@ 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

@@ -133,7 +133,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")]
@@ -200,23 +200,6 @@ fn default_backlog_range() -> u64 {
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct EscalationPolicyConfig {
-    // The keeper will perform the callback as long as the tx is within this percentage of the configured gas limit.
-    // Default value is 110, meaning a 10% tolerance over the configured value.
-    #[serde(default = "default_gas_limit_tolerance_pct")]
-    pub gas_limit_tolerance_pct: u64,
-
-    /// The initial gas multiplier to apply to the tx gas estimate
-    #[serde(default = "default_initial_gas_multiplier_pct")]
-    pub initial_gas_multiplier_pct: u64,
-
-    /// The gas multiplier to apply to the tx gas estimate during backoff retries.
-    /// The gas on each successive retry is multiplied by this value, with the maximum multiplier capped at `gas_multiplier_cap_pct`.
-    #[serde(default = "default_gas_multiplier_pct")]
-    pub gas_multiplier_pct: u64,
-    /// The maximum gas multiplier to apply to the tx gas estimate during backoff retries.
-    #[serde(default = "default_gas_multiplier_cap_pct")]
-    pub gas_multiplier_cap_pct: u64,
-
     /// The fee multiplier to apply to the fee during backoff retries.
     /// The initial fee is 100% of the estimate (which itself may be padded based on our chain configuration)
     /// The fee on each successive retry is multiplied by this value, with the maximum multiplier capped at `fee_multiplier_cap_pct`.
@@ -226,22 +209,6 @@ pub struct EscalationPolicyConfig {
     pub fee_multiplier_cap_pct: u64,
 }
 
-fn default_gas_limit_tolerance_pct() -> u64 {
-    110
-}
-
-fn default_initial_gas_multiplier_pct() -> u64 {
-    125
-}
-
-fn default_gas_multiplier_pct() -> u64 {
-    110
-}
-
-fn default_gas_multiplier_cap_pct() -> u64 {
-    600
-}
-
 fn default_fee_multiplier_pct() -> u64 {
     110
 }
@@ -253,10 +220,6 @@ fn default_fee_multiplier_cap_pct() -> u64 {
 impl Default for EscalationPolicyConfig {
     fn default() -> Self {
         Self {
-            gas_limit_tolerance_pct: default_gas_limit_tolerance_pct(),
-            initial_gas_multiplier_pct: default_initial_gas_multiplier_pct(),
-            gas_multiplier_pct: default_gas_multiplier_pct(),
-            gas_multiplier_cap_pct: default_gas_multiplier_cap_pct(),
             fee_multiplier_pct: default_fee_multiplier_pct(),
             fee_multiplier_cap_pct: default_fee_multiplier_cap_pct(),
         }
@@ -266,10 +229,6 @@ impl Default for EscalationPolicyConfig {
 impl EscalationPolicyConfig {
     pub fn to_policy(&self) -> EscalationPolicy {
         EscalationPolicy {
-            gas_limit_tolerance_pct: self.gas_limit_tolerance_pct,
-            initial_gas_multiplier_pct: self.initial_gas_multiplier_pct,
-            gas_multiplier_pct: self.gas_multiplier_pct,
-            gas_multiplier_cap_pct: self.gas_multiplier_cap_pct,
             fee_multiplier_pct: self.fee_multiplier_pct,
             fee_multiplier_cap_pct: self.fee_multiplier_cap_pct,
         }