chore(apps/fortuna): update to stable rust

Riateche · Riateche · commit 234a07e9cb9f · 2024-11-05T14:31:58.000Z
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -66,6 +66,12 @@ repos:
         entry: cargo +nightly-2023-07-23 fmt --manifest-path ./apps/fortuna/Cargo.toml --all -- --config-path rustfmt.toml
         pass_filenames: false
         files: apps/fortuna
+      - id: cargo-clippy-fortuna
+        name: Cargo clippy for Fortuna
+        language: "rust"
+        entry: cargo +1.82.0 clippy --manifest-path ./apps/fortuna/Cargo.toml --tests --fix --allow-dirty --allow-staged -- -D warnings
+        pass_filenames: false
+        files: apps/fortuna
       # Hooks for message buffer contract
       - id: cargo-fmt-message-buffer
         name: Cargo format for message buffer contract
diff --git a/apps/fortuna/Cargo.lock b/apps/fortuna/Cargo.lock
diff --git a/apps/fortuna/Dockerfile b/apps/fortuna/Dockerfile
@@ -1,10 +1,7 @@
-ARG RUST_VERSION=1.66.1
+ARG RUST_VERSION=1.82.0
 
 FROM rust:${RUST_VERSION} AS build
 
-# Set default toolchain
-RUN rustup default nightly-2023-07-23
-
 # Build
 WORKDIR /src
 COPY apps/fortuna apps/fortuna
diff --git a/apps/fortuna/rust-toolchain b/apps/fortuna/rust-toolchain
@@ -1 +1 @@
-nightly-2023-07-23
+1.82.0
diff --git a/apps/fortuna/src/api/revelation.rs b/apps/fortuna/src/api/revelation.rs
@@ -58,7 +58,7 @@ pub async fn revelation(
     let state = state
         .chains
         .get(&chain_id)
-        .ok_or_else(|| RestError::InvalidChainId)?;
+        .ok_or(RestError::InvalidChainId)?;
 
     let maybe_request_fut = state.contract.get_request(state.provider_address, sequence);
 
@@ -85,7 +85,7 @@ pub async fn revelation(
                 );
                 RestError::Unknown
             })?;
-            let encoded_value = Blob::new(encoding.unwrap_or(BinaryEncoding::Hex), value.clone());
+            let encoded_value = Blob::new(encoding.unwrap_or(BinaryEncoding::Hex), *value);
 
             Ok(Json(GetRandomValueResponse {
                 value: encoded_value,
diff --git a/apps/fortuna/src/chain/ethereum.rs b/apps/fortuna/src/chain/ethereum.rs
@@ -204,10 +204,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
             if let PythRandomEvents::RequestedFilter(r) = PythRandomEvents::decode_log(&l)? {
                 Ok(r.request.sequence_number)
             } else {
-                Err(anyhow!("No log with sequence number").into())
+                Err(anyhow!("No log with sequence number"))
             }
         } else {
-            Err(anyhow!("Request failed").into())
+            Err(anyhow!("Request failed"))
         }
     }
 
@@ -238,10 +238,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
             {
                 Ok(r.random_number)
             } else {
-                Err(anyhow!("No log with randomnumber").into())
+                Err(anyhow!("No log with randomnumber"))
             }
         } else {
-            Err(anyhow!("Request failed").into())
+            Err(anyhow!("Request failed"))
         }
     }
 
diff --git a/apps/fortuna/src/chain/reader.rs b/apps/fortuna/src/chain/reader.rs
@@ -23,9 +23,9 @@ pub enum BlockStatus {
     Safe,
 }
 
-impl Into<EthersBlockNumber> for BlockStatus {
-    fn into(self) -> EthersBlockNumber {
-        match self {
+impl From<BlockStatus> for EthersBlockNumber {
+    fn from(val: BlockStatus) -> Self {
+        match val {
             BlockStatus::Latest => EthersBlockNumber::Latest,
             BlockStatus::Finalized => EthersBlockNumber::Finalized,
             BlockStatus::Safe => EthersBlockNumber::Safe,
diff --git a/apps/fortuna/src/command/generate.rs b/apps/fortuna/src/command/generate.rs
@@ -56,7 +56,7 @@ pub async fn generate(opts: &GenerateOptions) -> Result<()> {
             &provider,
             sequence_number,
             &user_randomness,
-            &provider_randomness,
+            provider_randomness,
         )
         .await?;
 
diff --git a/apps/fortuna/src/command/register_provider.rs b/apps/fortuna/src/command/register_provider.rs
@@ -56,7 +56,7 @@ pub async fn register_provider_from_config(
 
     // Initialize a Provider to interface with the EVM contract.
     let contract =
-        Arc::new(SignablePythContract::from_config(&chain_config, &private_key_string).await?);
+        Arc::new(SignablePythContract::from_config(chain_config, &private_key_string).await?);
     // Create a new random hash chain.
     let random = rand::random::<[u8; 32]>();
     let secret = provider_config
@@ -68,7 +68,7 @@ pub async fn register_provider_from_config(
     tracing::info!("Generating hash chain");
     let chain = PebbleHashChain::from_config(
         &secret,
-        &chain_id,
+        chain_id,
         &private_key_string.parse::<LocalWallet>()?.address(),
         &chain_config.contract_addr,
         &random,
@@ -86,7 +86,7 @@ pub async fn register_provider_from_config(
         seed:         random,
         chain_length: commitment_length,
     };
-    let uri = get_register_uri(&provider_config.uri, &chain_id)?;
+    let uri = get_register_uri(&provider_config.uri, chain_id)?;
     let call = contract.register(
         fee_in_wei,
         commitment,
@@ -98,7 +98,7 @@ pub async fn register_provider_from_config(
     );
     let mut gas_estimate = call.estimate_gas().await?;
     let gas_multiplier = U256::from(2); //TODO: smarter gas estimation
-    gas_estimate = gas_estimate * gas_multiplier;
+    gas_estimate *= gas_multiplier;
     let call_with_gas = call.gas(gas_estimate);
     if let Some(r) = call_with_gas.send().await?.await? {
         tracing::info!("Registered provider: {:?}", r);
diff --git a/apps/fortuna/src/command/run.rs b/apps/fortuna/src/command/run.rs
@@ -237,7 +237,7 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
         rpc_metrics.clone(),
     ));
 
-    run_api(opts.addr.clone(), chains, metrics_registry, rx_exit).await?;
+    run_api(opts.addr, chains, metrics_registry, rx_exit).await?;
 
     Ok(())
 }
@@ -251,11 +251,11 @@ async fn setup_chain_state(
     rpc_metrics: Arc<RpcMetrics>,
 ) -> Result<BlockchainState> {
     let contract = Arc::new(InstrumentedPythContract::from_config(
-        &chain_config,
+        chain_config,
         chain_id.clone(),
         rpc_metrics,
     )?);
-    let mut provider_commitments = chain_config.commitments.clone().unwrap_or(Vec::new());
+    let mut provider_commitments = chain_config.commitments.clone().unwrap_or_default();
     provider_commitments.sort_by(|c1, c2| {
         c1.original_commitment_sequence_number
             .cmp(&c2.original_commitment_sequence_number)
@@ -301,9 +301,9 @@ async fn setup_chain_state(
         offsets.push(offset);
 
         let pebble_hash_chain = PebbleHashChain::from_config(
-            &secret,
-            &chain_id,
-            &provider,
+            secret,
+            chain_id,
+            provider,
             &chain_config.contract_addr,
             &commitment.seed,
             commitment.chain_length,
@@ -321,7 +321,7 @@ async fn setup_chain_state(
     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());
+        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));
     } else {
         tracing::info!("Root of chain id {} matches commitment", &chain_id);
     }
@@ -330,7 +330,7 @@ async fn setup_chain_state(
         id: chain_id.clone(),
         state: Arc::new(chain_state),
         contract,
-        provider_address: provider.clone(),
+        provider_address: *provider,
         reveal_delay_blocks: chain_config.reveal_delay_blocks,
         confirmed_block_status: chain_config.confirmed_block_status,
     };
diff --git a/apps/fortuna/src/command/setup_provider.rs b/apps/fortuna/src/command/setup_provider.rs
@@ -99,7 +99,7 @@ async fn setup_chain_provider(
     ))?;
     let provider_address = private_key.clone().parse::<LocalWallet>()?.address();
     // Initialize a Provider to interface with the EVM contract.
-    let contract = Arc::new(SignablePythContract::from_config(&chain_config, &private_key).await?);
+    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?;
@@ -140,7 +140,7 @@ async fn setup_chain_provider(
         } else {
             let hash_chain = PebbleHashChain::from_config(
                 &secret,
-                &chain_id,
+                chain_id,
                 &provider_address,
                 &chain_config.contract_addr,
                 &metadata.seed,
@@ -167,7 +167,7 @@ async fn setup_chain_provider(
     }
     if register {
         tracing::info!("Registering");
-        register_provider_from_config(&provider_config, &chain_id, &chain_config)
+        register_provider_from_config(provider_config, chain_id, chain_config)
             .await
             .map_err(|e| anyhow!("Chain: {} - Failed to register provider: {}", &chain_id, e))?;
         tracing::info!("Registered");
@@ -180,7 +180,7 @@ async fn setup_chain_provider(
         .in_current_span()
         .await?;
 
-    let uri = get_register_uri(&provider_config.uri, &chain_id)?;
+    let uri = get_register_uri(&provider_config.uri, chain_id)?;
     sync_uri(&contract, &provider_info, uri)
         .in_current_span()
         .await?;
@@ -210,7 +210,7 @@ async fn sync_uri(
     uri: String,
 ) -> Result<()> {
     let uri_as_bytes: Bytes = AbiBytes::from(uri.as_str()).into();
-    if &provider_info.uri != &uri_as_bytes {
+    if provider_info.uri != uri_as_bytes {
         tracing::info!("Updating provider uri to {}", uri);
         if let Some(receipt) = contract
             .set_provider_uri(uri_as_bytes)
diff --git a/apps/fortuna/src/command/withdraw_fees.rs b/apps/fortuna/src/command/withdraw_fees.rs
@@ -32,11 +32,11 @@ pub async fn withdraw_fees(opts: &WithdrawFeesOptions) -> Result<()> {
         Some(chain_id) => {
             let chain_config = &config.get_chain_config(&chain_id)?;
             let contract =
-                SignablePythContract::from_config(&chain_config, &private_key_string).await?;
+                SignablePythContract::from_config(chain_config, &private_key_string).await?;
 
             withdraw_fees_for_chain(
                 contract,
-                config.provider.address.clone(),
+                config.provider.address,
                 opts.keeper,
                 opts.retain_balance_wei,
             )
@@ -46,11 +46,11 @@ pub async fn withdraw_fees(opts: &WithdrawFeesOptions) -> Result<()> {
             for (chain_id, chain_config) in config.chains.iter() {
                 tracing::info!("Withdrawing fees for chain: {}", chain_id);
                 let contract =
-                    SignablePythContract::from_config(&chain_config, &private_key_string).await?;
+                    SignablePythContract::from_config(chain_config, &private_key_string).await?;
 
                 withdraw_fees_for_chain(
                     contract,
-                    config.provider.address.clone(),
+                    config.provider.address,
                     opts.keeper,
                     opts.retain_balance_wei,
                 )
diff --git a/apps/fortuna/src/config.rs b/apps/fortuna/src/config.rs
@@ -118,10 +118,10 @@ impl Config {
     }
 
     pub fn get_chain_config(&self, chain_id: &ChainId) -> Result<EthereumConfig> {
-        self.chains
-            .get(chain_id)
-            .map(|x| x.clone())
-            .ok_or(anyhow!("Could not find chain id {} in the configuration", &chain_id).into())
+        self.chains.get(chain_id).cloned().ok_or(anyhow!(
+            "Could not find chain id {} in the configuration",
+            &chain_id
+        ))
     }
 }
 
@@ -261,16 +261,12 @@ pub struct SecretString {
 
 impl SecretString {
     pub fn load(&self) -> Result<Option<String>> {
-        match &self.value {
-            Some(v) => return Ok(Some(v.clone())),
-            _ => {}
+        if let Some(v) = &self.value {
+            return Ok(Some(v.clone()));
         }
 
-        match &self.file {
-            Some(v) => {
-                return Ok(Some(fs::read_to_string(v)?.trim().to_string()));
-            }
-            _ => {}
+        if let Some(v) = &self.file {
+            return Ok(Some(fs::read_to_string(v)?.trim().to_string()));
         }
 
         Ok(None)
diff --git a/apps/fortuna/src/keeper.rs b/apps/fortuna/src/keeper.rs
diff --git a/apps/fortuna/src/main.rs b/apps/fortuna/src/main.rs
diff --git a/apps/fortuna/src/state.rs b/apps/fortuna/src/state.rs

Original file line number	Diff line number	Diff line change
`@@ -204,10 +204,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {`
`204`	`204`	`if let PythRandomEvents::RequestedFilter(r) = PythRandomEvents::decode_log(&l)? {`
`205`	`205`	`Ok(r.request.sequence_number)`
`206`	`206`	`} else {`
`207`		`- Err(anyhow!("No log with sequence number").into())`
	`207`	`+ Err(anyhow!("No log with sequence number"))`
`208`	`208`	`}`
`209`	`209`	`} else {`
`210`		`- Err(anyhow!("Request failed").into())`
	`210`	`+ Err(anyhow!("Request failed"))`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
`@@ -238,10 +238,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {`
`238`	`238`	`{`
`239`	`239`	`Ok(r.random_number)`
`240`	`240`	`} else {`
`241`		`- Err(anyhow!("No log with randomnumber").into())`
	`241`	`+ Err(anyhow!("No log with randomnumber"))`
`242`	`242`	`}`
`243`	`243`	`} else {`
`244`		`- Err(anyhow!("Request failed").into())`
	`244`	`+ Err(anyhow!("Request failed"))`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ pub async fn generate(opts: &GenerateOptions) -> Result<()> {`
`56`	`56`	`&provider,`
`57`	`57`	`sequence_number,`
`58`	`58`	`&user_randomness,`
`59`		`- &provider_randomness,`
	`59`	`+ provider_randomness,`
`60`	`60`	`)`
`61`	`61`	`.await?;`
`62`	`62`