relayer and lc fixes

e2e/interchaintestv8/chainconfig/kurtosis.go

@@ -32,7 +32,7 @@ var (
 		Participants: []kurtosisParticipant{
 			{
 				CLType:     "lodestar",
-				CLImage:    "ethpandaops/lighthouse:unstable",
+				CLImage:    "ethpandaops/lodestar:prague-devnet-6",
 				ELType:     "geth",
 				ELImage:    "ethpandaops/geth:prague-devnet-6",
 				ELLogLevel: "info",

e2e/interchaintestv8/e2esuite/suite.go

@@ -50,17 +50,21 @@ func (s *TestSuite) SetupSuite(ctx context.Context) {
 	case testvalues.EthTestnetTypePoW:
 		icChainSpecs = append(icChainSpecs, &interchaintest.ChainSpec{ChainConfig: icethereum.DefaultEthereumAnvilChainConfig("ethereum")})
 	case testvalues.EthTestnetTypePoS:
-		kurtosisChain, err := chainconfig.SpinUpKurtosisPoS(ctx) // TODO: Run this in a goroutine and wait for it to be ready
+		// kurtosisChain, err := chainconfig.SpinUpKurtosisPoS(ctx) // TODO: Run this in a goroutine and wait for it to be ready
+		// s.Require().NoError(err)
+		faucet, err := crypto.ToECDSA(ethcommon.FromHex("04b9f63ecf84210c5366c66d68fa1f5da1fa4f634fad6dfc86178e4d79ff9e59"))
 		s.Require().NoError(err)
-		s.EthChain, err = ethereum.NewEthereum(ctx, kurtosisChain.RPC, &kurtosisChain.BeaconApiClient, kurtosisChain.Faucet)
+
+		beaconAPI := ethereum.NewBeaconAPIClient("http://127.0.0.1:33195")
+		s.EthChain, err = ethereum.NewEthereum(ctx, "http://127.0.0.1:33190", &beaconAPI, faucet)
 		s.Require().NoError(err)
-		s.T().Cleanup(func() {
-			ctx := context.Background()
-			if s.T().Failed() {
-				_ = kurtosisChain.DumpLogs(ctx)
-			}
-			kurtosisChain.Destroy(ctx)
-		})
+		// s.T().Cleanup(func() {
+		// 	ctx := context.Background()
+		// 	if s.T().Failed() {
+		// 		_ = kurtosisChain.DumpLogs(ctx)
+		// 	}
+		// 	kurtosisChain.Destroy(ctx)
+		// })
 	case testvalues.EthTestnetTypeNone:
 		// Do nothing
 	default:

e2e/interchaintestv8/ibc_eureka_test.go

@@ -524,6 +524,9 @@ func (s *IbcEurekaTestSuite) ICS20TransferERC20TokenfromEthereumToCosmosAndBackT
 	s.Require().True(s.Run("Receive packets on Cosmos chain", func() {
 		var relayTxBodyBz []byte
 		s.Require().True(s.Run("Retrieve relay tx", func() {
+			// fmt.Println("Sleeping for 120 minutes, to test")
+			// fmt.Printf("Relay request: SrcChain: %s\n DstChain: %s\n SourceTxIds: %v\n TargetClientId: %s\n", eth.ChainID.String(), simd.Config().ChainID, ethcommon.BytesToHash(ethSendTxHash).String(), testvalues.FirstWasmClientID)
+			// time.Sleep(120 * time.Minute)
 			resp, err := s.RelayerClient.RelayByTx(context.Background(), &relayertypes.RelayByTxRequest{
 				SrcChain:       eth.ChainID.String(),
 				DstChain:       simd.Config().ChainID,

e2e/interchaintestv8/types/rust_fixtures.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/stretchr/testify/suite"
 
@@ -31,6 +32,9 @@ func NewRustFixtureGenerator(s *suite.Suite, shouldGenerateFixture bool) *RustFi
 			if err := rustFixtureGenerator.writeFixtures(fixtureName); err != nil {
 				s.T().Logf("Error writing fixtures: %v", err)
 			}
+
+			fmt.Println("Sleeping for 120 minutes after writing fixtures")
+			time.Sleep(120 * time.Minute)
 		})
 	}
 

justfile

@@ -144,6 +144,10 @@ install-operator:
 install-relayer:
 	cargo install --bin relayer --path programs/relayer --locked
 
+run-relayer:
+	@echo "Running the relayer..."
+	cargo run --bin relayer --release -- start --config config.json
+
 # Generate the `genesis.json` file using $TENDERMINT_RPC_URL in the `.env` file
 # Note that the `scripts/genesis.json` file is ignored in the `.gitignore` file
 genesis-sp1-ics07: build-sp1-programs

packages/ethereum/ethereum-apis/src/beacon_api/client.rs

@@ -1,6 +1,7 @@
 //! This module implements the `BeaconApiClient` to interact with the Ethereum Beacon API.
 
 use ethereum_types::consensus::{
+    bootstrap::LightClientBootstrap,
     light_client_header::{LightClientFinalityUpdate, LightClientUpdate},
     spec::Spec,
 };
@@ -10,11 +11,13 @@ use tracing::debug;
 
 use super::{
     error::{BeaconApiClientError, InternalServerError, NotFoundError},
-    response::{Response, Version},
+    response::{BeaconBlockRoot, Response, Version},
 };
 
 const SPEC_PATH: &str = "/eth/v1/config/spec";
-const FINALITY_UPDATE_PATH: &str = "/eth/v1/beacon/light_client/finality_update";
+const BEACON_BLOCKS_PATH: &str = "/eth/v1/beacon/blocks";
+const LIGHT_CLIENT_BOOTSTRAP_PATH: &str = "/eth/v1/beacon/light_client/bootstrap";
+const LIGHT_CLIENT_FINALITY_UPDATE_PATH: &str = "/eth/v1/beacon/light_client/finality_update";
 const LIGHT_CLIENT_UPDATES_PATH: &str = "/eth/v1/beacon/light_client/updates";
 
 /// The api client for interacting with the Beacon API
@@ -41,13 +44,37 @@ impl BeaconApiClient {
         self.get_json(SPEC_PATH).await
     }
 
+    /// Fetches the `LigthClientBootstrap` for a given beacon block root
+    /// # Errors
+    /// Returns an error if the request fails or the response is not successful deserialized
+    pub async fn light_client_bootstrap(
+        &self,
+        beacon_block_root: &str,
+    ) -> Result<Response<LightClientBootstrap>, BeaconApiClientError> {
+        self.get_json(&format!(
+            "{LIGHT_CLIENT_BOOTSTRAP_PATH}/{beacon_block_root}"
+        ))
+        .await
+    }
+
+    /// Fetches the Beacon block root for a given block id
+    /// # Errors
+    /// Returns an error if the request fails or the response is not successful deserialized
+    pub async fn beacon_block_root(&self, block_id: &str) -> Result<String, BeaconApiClientError> {
+        let resp: Response<BeaconBlockRoot> = self
+            .get_json(&format!("{BEACON_BLOCKS_PATH}/{block_id}/root"))
+            .await?;
+
+        Ok(resp.data.root)
+    }
+
     /// Fetches the latest Beacon light client finality update
     /// # Errors
     /// Returns an error if the request fails or the response is not successful deserialized
     pub async fn finality_update(
         &self,
     ) -> Result<Response<LightClientFinalityUpdate, Version>, BeaconApiClientError> {
-        self.get_json(FINALITY_UPDATE_PATH).await
+        self.get_json(LIGHT_CLIENT_FINALITY_UPDATE_PATH).await
     }
 
     /// Fetches Beacon light client updates starting from a given period

packages/ethereum/ethereum-apis/src/beacon_api/response.rs

@@ -40,3 +40,10 @@ pub struct Version {
     /// The version of the Ethereum consensus.
     pub version: EthConsensusVersion,
 }
+
+/// The Beacon Block Root response structure returned by the Beacon API.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BeaconBlockRoot {
+    /// The root of the Beacon block.
+    pub root: String,
+}

packages/ethereum/ethereum-light-client/src/verify.rs

@@ -90,9 +90,14 @@ pub fn verify_header<V: BlsVerify>(
     );
 
     let proof_data = header.account_update.account_proof.clone();
+    print!("{proof_data:?}");
 
     verify_account_storage_root(
-        header.consensus_update.attested_header.execution.state_root,
+        header
+            .consensus_update
+            .finalized_header
+            .execution
+            .state_root,
         client_state.ibc_contract_address,
         &proof_data.proof,
         proof_data.storage_root,

packages/ethereum/ethereum-types/src/consensus/bootstrap.rs

@@ -0,0 +1,23 @@
+//! This module defines types related to the bootstrap endpoint of the Beacon API.
+
+use alloy_primitives::B256;
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+
+use super::{
+    light_client_header::LightClientHeader, merkle::CURRENT_SYNC_COMMITTEE_BRANCH_DEPTH,
+    sync_committee::SyncCommittee,
+};
+
+/// The light client bootstrap
+#[serde_as]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug, Default)]
+#[allow(clippy::module_name_repetitions)]
+pub struct LightClientBootstrap {
+    /// The light client header
+    pub header: LightClientHeader,
+    /// The current sync committee
+    pub current_sync_committee: SyncCommittee,
+    /// The branch of the current sync committee
+    pub current_sync_committee_branch: [B256; CURRENT_SYNC_COMMITTEE_BRANCH_DEPTH],
+}

packages/ethereum/ethereum-types/src/consensus/light_client_header.rs

@@ -56,6 +56,21 @@ pub struct LightClientFinalityUpdate {
     pub signature_slot: u64,
 }
 
+// Light Client Finality Update to Light Client Update conversion
+impl From<LightClientFinalityUpdate> for LightClientUpdate {
+    fn from(finality_update: LightClientFinalityUpdate) -> Self {
+        Self {
+            attested_header: finality_update.attested_header,
+            next_sync_committee: None,
+            next_sync_committee_branch: None,
+            finalized_header: finality_update.finalized_header,
+            finality_branch: finality_update.finality_branch,
+            sync_aggregate: finality_update.sync_aggregate,
+            signature_slot: finality_update.signature_slot,
+        }
+    }
+}
+
 /// The header of a light client
 #[derive(Serialize, Deserialize, JsonSchema, PartialEq, Eq, Clone, Debug, Default, TreeHash)]
 #[allow(clippy::module_name_repetitions)]

packages/ethereum/ethereum-types/src/consensus/merkle.rs

@@ -17,6 +17,9 @@ pub const EXECUTION_PAYLOAD_INDEX: u64 = 25;
 
 /// The depth of the merkle tree for execution payloads.
 pub const EXECUTION_BRANCH_DEPTH: usize = floorlog2(EXECUTION_PAYLOAD_INDEX);
+/// The depth of the merkle tree for the current sync committee.
+pub const CURRENT_SYNC_COMMITTEE_BRANCH_DEPTH: usize =
+    floorlog2(CURRENT_SYNC_COMMITTEE_GINDEX_ELECTRA);
 /// The depth of the merkle tree for the next sync committee.
 pub const NEXT_SYNC_COMMITTEE_BRANCH_DEPTH: usize = floorlog2(NEXT_SYNC_COMMITTEE_GINDEX_ELECTRA);
 /// The depth of the merkle tree for the finalized root.

packages/ethereum/ethereum-types/src/consensus/mod.rs

@@ -1,6 +1,7 @@
 //! This module contains types assosicated with the beacon api and Ethereum consensus.
 
 pub mod bls;
+pub mod bootstrap;
 pub mod domain;
 pub mod fork;
 pub mod light_client_header;

packages/relayer-lib/src/events/eureka.rs

@@ -2,7 +2,8 @@
 
 use alloy::{
     primitives::{hex, Bytes},
-    sol_types::SolEvent,
+    rpc::types::Log,
+    sol_types::{SolEvent, SolEventInterface},
 };
 use ibc_eureka_solidity_types::ics26::{
     router::{routerEvents, SendPacket, WriteAcknowledgement},
@@ -19,9 +20,9 @@ use super::cosmos_sdk;
 #[allow(clippy::module_name_repetitions)]
 pub enum EurekaEvent {
     /// A packet was sent.
-    SendPacket(SolPacket),
+    SendPacket(SolPacket, Option<u64>),
     /// An acknowledgement was written.
-    WriteAcknowledgement(SolPacket, Vec<Bytes>),
+    WriteAcknowledgement(SolPacket, Vec<Bytes>, Option<u64>),
 }
 
 impl EurekaEvent {
@@ -33,15 +34,22 @@ impl EurekaEvent {
     }
 }
 
-impl TryFrom<routerEvents> for EurekaEvent {
+impl TryFrom<&Log> for EurekaEvent {
     type Error = anyhow::Error;
 
-    fn try_from(event: routerEvents) -> anyhow::Result<Self> {
-        match event {
-            routerEvents::SendPacket(event) => Ok(Self::SendPacket(event.packet)),
+    fn try_from(log: &Log) -> anyhow::Result<Self> {
+        let sol_event = routerEvents::decode_log(&log.inner, true).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to decode log into ICS26Router event: {}",
+                e.to_string()
+            )
+        })?;
+        match sol_event.data {
+            routerEvents::SendPacket(event) => Ok(Self::SendPacket(event.packet, log.block_number)),
             routerEvents::WriteAcknowledgement(event) => Ok(Self::WriteAcknowledgement(
                 event.packet,
                 event.acknowledgements,
+                log.block_number,
             )),
             routerEvents::AckPacket(_) => Err(anyhow::anyhow!("AckPacket event is not used")),
             routerEvents::TimeoutPacket(_) => {
@@ -82,7 +90,7 @@ impl TryFrom<TmEvent> for EurekaEvent {
                     }
                     let packet: Vec<u8> = hex::decode(attr.value_str().ok()?).ok()?;
                     let packet = Packet::decode(packet.as_slice()).ok()?;
-                    Some(Self::SendPacket(packet.into()))
+                    Some(Self::SendPacket(packet.into(), None))
                 })
                 .ok_or_else(|| anyhow::anyhow!("No packet data found")),
             cosmos_sdk::EVENT_TYPE_WRITE_ACK => {
@@ -115,6 +123,7 @@ impl TryFrom<TmEvent> for EurekaEvent {
                         .into_iter()
                         .map(Into::into)
                         .collect(),
+                    None,
                 ))
             }
             cosmos_sdk::EVENT_TYPE_ACKNOWLEDGE_PACKET

packages/relayer-lib/src/listener/eth_eureka.rs

@@ -4,11 +4,10 @@ use alloy::{
     primitives::{Address, TxHash},
     providers::Provider,
     rpc::types::Filter,
-    sol_types::SolEventInterface,
 };
 use anyhow::{anyhow, Result};
 use futures::future;
-use ibc_eureka_solidity_types::ics26::router::{routerEvents, routerInstance};
+use ibc_eureka_solidity_types::ics26::router::routerInstance;
 
 use crate::{chain::EthEureka, events::EurekaEvent};
 
@@ -75,10 +74,7 @@ where
                         .await?
                         .iter()
                         .filter(|log| log.transaction_hash.unwrap_or_default() == tx_id)
-                        .filter_map(|log| {
-                            let sol_event = routerEvents::decode_log(&log.inner, true).ok()?.data;
-                            EurekaEvent::try_from(sol_event).ok()
-                        })
+                        .filter_map(|log| EurekaEvent::try_from(log).ok())
                         .collect::<Vec<_>>(),
                 )
             }))
@@ -102,10 +98,7 @@ where
             .get_logs(&event_filter)
             .await?
             .iter()
-            .filter_map(|log| {
-                let sol_event = routerEvents::decode_log(&log.inner, true).ok()?.data;
-                EurekaEvent::try_from(sol_event).ok()
-            })
+            .filter_map(|log| EurekaEvent::try_from(log).ok())
             .collect())
     }
 }