chore(test): fix helios test (#34)

* feat: fix helios test

* fix

* clippy

* fix: test

* fix

Author: ratankaliani

.github/workflows/run_program.yaml

@@ -15,9 +15,7 @@ concurrency:
 jobs:
   run_program:
     name: Test SP1 Helios Program
-    runs-on: [runs-on, runner=4cpu-linux-arm64	, "run-id=${{ github.run_id }}"]
-    env:
-      CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+    runs-on: [runs-on, runner=32cpu-linux-x64, "run-id=${{ github.run_id }}"]
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4

elf/sp1-helios-elf

@@ -55,8 +55,7 @@ pub fn main() {
     )
     .expect("Finality update failed to verify.");
 
-    apply_finality_update(&mut store, &finality_update)
-        .expect("A valid finality update should always apply.");
+    apply_finality_update(&mut store, &finality_update);
 
     // Ensure the new head is greater than the previous head. This guarantees that the finality
     // update was correctly applied.

program/src/main.rs

@@ -63,7 +63,7 @@ pub async fn main() -> Result<()> {
 
     let checkpoint;
     if let Some(temp_slot) = args.slot {
-        checkpoint = get_checkpoint(temp_slot).await;
+        checkpoint = get_checkpoint(temp_slot).await?;
     } else {
         checkpoint = get_latest_checkpoint().await;
     }
@@ -74,7 +74,7 @@ pub async fn main() -> Result<()> {
         verifier = env::var("SP1_VERIFIER_ADDRESS").unwrap().parse().unwrap();
     }
 
-    let helios_client = get_client(checkpoint).await;
+    let helios_client = get_client(checkpoint).await?;
     let finalized_header = helios_client
         .store
         .finalized_header

script/bin/genesis.rs

@@ -238,10 +238,10 @@ impl SP1HeliosOperator {
                 .unwrap();
 
             // Fetch the checkpoint at that slot
-            let checkpoint = get_checkpoint(slot).await;
+            let checkpoint = get_checkpoint(slot).await?;
 
             // Get the client from the checkpoint
-            let client = get_client(checkpoint).await;
+            let client = get_client(checkpoint).await?;
 
             // Request an update
             match self.request_update(client).await {

script/bin/operator.rs

@@ -1,3 +1,4 @@
+use alloy_primitives::B256;
 use anyhow::Result;
 use clap::{command, Parser};
 use helios_ethereum::rpc::ConsensusRpc;
@@ -19,19 +20,47 @@ async fn main() -> Result<()> {
     setup_logger();
     let args = GenesisArgs::parse();
 
-    // Get the current slot from the contract or fetch the latest checkpoint
-    let checkpoint = if let Some(slot) = args.slot {
-        get_checkpoint(slot).await
-    } else {
-        get_latest_checkpoint().await
+    // Get the latest checkpoint.
+    let slot = match args.slot {
+        Some(s) => s,
+        None => {
+            // Get latest checkpoint and use it to determine current slot
+            let latest_checkpoint = get_latest_checkpoint().await;
+            let client = get_client(latest_checkpoint).await?;
+            client.expected_current_slot()
+        }
     };
 
-    // Setup client.
-    let helios_client = get_client(checkpoint).await;
+    // Find a valid checkpoint by searching backwards from the slot
+    let mut checkpoint = B256::ZERO;
+    let mut checkpoint_slot: u64 = 0;
+    for i in slot.saturating_sub(8000)..slot {
+        if let Ok(cp) = get_checkpoint(i).await {
+            if get_client(cp).await.is_ok() {
+                checkpoint = cp;
+                checkpoint_slot = i;
+                break;
+            }
+        }
+    }
+
+    // Setup client with the found checkpoint
+    let helios_client = get_client(checkpoint).await?;
+
     let updates = get_updates(&helios_client).await;
     let finality_update = helios_client.rpc.get_finality_update().await.unwrap();
-
     let expected_current_slot = helios_client.expected_current_slot();
+
+    println!("Checkpoint slot: {}", checkpoint_slot);
+    println!(
+        "Finality update slot: {}",
+        finality_update.attested_header().beacon().slot
+    );
+    println!(
+        "Finality update signature slot: {}",
+        finality_update.signature_slot()
+    );
+
     let inputs = ProofInputs {
         updates,
         finality_update,
@@ -46,7 +75,10 @@ async fn main() -> Result<()> {
     stdin.write_slice(&serde_cbor::to_vec(&inputs)?);
 
     let prover_client = ProverClient::builder().cpu().build();
-    let (_, report) = prover_client.execute(ELF, &stdin).run()?;
+    let (_, report) = prover_client
+        .execute(ELF, &stdin)
+        .calculate_gas(false)
+        .run()?;
     println!("Execution Report: {:?}", report);
 
     Ok(())

script/bin/test.rs

@@ -11,6 +11,7 @@ use helios_ethereum::{
     rpc::http_rpc::HttpRpc,
 };
 
+use anyhow::{anyhow, Result};
 use std::sync::Arc;
 use tokio::sync::{mpsc::channel, watch};
 use tree_hash::TreeHash;
@@ -47,7 +48,7 @@ pub async fn get_latest_checkpoint() -> B256 {
 }
 
 /// Fetch checkpoint from a slot number.
-pub async fn get_checkpoint(slot: u64) -> B256 {
+pub async fn get_checkpoint(slot: u64) -> Result<B256> {
     let consensus_rpc = std::env::var("SOURCE_CONSENSUS_RPC_URL").unwrap();
     let chain_id = std::env::var("SOURCE_CHAIN_ID").unwrap();
     let network = Network::from_chain_id(chain_id.parse().unwrap()).unwrap();
@@ -73,13 +74,17 @@ pub async fn get_checkpoint(slot: u64) -> B256 {
         Arc::new(config),
     );
 
-    let block: BeaconBlock<MainnetConsensusSpec> = client.rpc.get_block(slot).await.unwrap();
+    let block: BeaconBlock<MainnetConsensusSpec> = client
+        .rpc
+        .get_block(slot)
+        .await
+        .map_err(|e| anyhow!("error getting block: {}", e.to_string()))?;
 
-    B256::from_slice(block.tree_hash_root().as_ref())
+    Ok(B256::from_slice(block.tree_hash_root().as_ref()))
 }
 
 /// Setup a client from a checkpoint.
-pub async fn get_client(checkpoint: B256) -> Inner<MainnetConsensusSpec, HttpRpc> {
+pub async fn get_client(checkpoint: B256) -> Result<Inner<MainnetConsensusSpec, HttpRpc>> {
     let consensus_rpc = std::env::var("SOURCE_CONSENSUS_RPC_URL").unwrap();
     let chain_id = std::env::var("SOURCE_CHAIN_ID").unwrap();
     let network = Network::from_chain_id(chain_id.parse().unwrap()).unwrap();
@@ -106,6 +111,9 @@ pub async fn get_client(checkpoint: B256) -> Inner<MainnetConsensusSpec, HttpRpc
         Arc::new(config),
     );
 
-    client.bootstrap(checkpoint).await.unwrap();
     client
+        .bootstrap(checkpoint)
+        .await
+        .map_err(|e| anyhow!("error bootstrapping client: {}", e.to_string()))?;
+    Ok(client)
 }