feat: first indexer integration test

integration_tests/Cargo.toml

@@ -17,6 +17,7 @@ indexer_core.workspace = true
 wallet-ffi.workspace = true
 serde_json.workspace = true
 token_core.workspace = true
+indexer_service_rpc.workspace = true
 url.workspace = true
 
 anyhow.workspace = true

integration_tests/src/config.rs

@@ -12,8 +12,13 @@ use wallet::config::{
     InitialAccountData, InitialAccountDataPrivate, InitialAccountDataPublic, WalletConfig,
 };
 
-pub fn indexer_config(bedrock_addr: SocketAddr) -> Result<IndexerConfig> {
+pub fn indexer_config(
+    bedrock_addr: SocketAddr,
+    home: PathBuf,
+    initial_data: &InitialData,
+) -> Result<IndexerConfig> {
     Ok(IndexerConfig {
+        home,
         resubscribe_interval_millis: 1000,
         bedrock_client_config: ClientConfig {
             addr: addr_to_url(UrlProtocol::Http, bedrock_addr)
@@ -24,6 +29,9 @@ pub fn indexer_config(bedrock_addr: SocketAddr) -> Result<IndexerConfig> {
                 max_retries: 10,
             },
         },
+        initial_accounts: initial_data.sequencer_initial_accounts(),
+        initial_commitments: initial_data.sequencer_initial_commitments(),
+        signing_key: [37; 32],
         channel_id: bedrock_channel_id(),
     })
 }

integration_tests/src/lib.rs

@@ -10,6 +10,7 @@ use indexer_service::IndexerHandle;
 use log::{debug, error, warn};
 use nssa::{AccountId, PrivacyPreservingTransaction};
 use nssa_core::Commitment;
+use sequencer_core::indexer_client::{IndexerClient, IndexerClientTrait};
 use sequencer_runner::SequencerHandle;
 use tempfile::TempDir;
 use testcontainers::compose::DockerCompose;
@@ -33,10 +34,12 @@ static LOGGER: LazyLock<()> = LazyLock::new(env_logger::init);
 // NOTE: Order of fields is important for proper drop order.
 pub struct TestContext {
     sequencer_client: SequencerClient,
+    indexer_client: IndexerClient,
     wallet: WalletCore,
     sequencer_handle: SequencerHandle,
     indexer_handle: IndexerHandle,
     bedrock_compose: DockerCompose,
+    _temp_indexer_dir: TempDir,
     _temp_sequencer_dir: TempDir,
     _temp_wallet_dir: TempDir,
 }
@@ -62,7 +65,7 @@ impl TestContext {
 
         let (bedrock_compose, bedrock_addr) = Self::setup_bedrock_node().await?;
 
-        let indexer_handle = Self::setup_indexer(bedrock_addr)
+        let (indexer_handle, temp_indexer_dir) = Self::setup_indexer(bedrock_addr, &initial_data)
             .await
             .context("Failed to setup Indexer")?;
 
@@ -81,15 +84,22 @@ impl TestContext {
 
         let sequencer_url = config::addr_to_url(config::UrlProtocol::Http, sequencer_handle.addr())
             .context("Failed to convert sequencer addr to URL")?;
+        let indexer_url = config::addr_to_url(config::UrlProtocol::Ws, indexer_handle.addr())
+            .context("Failed to convert indexer addr to URL")?;
         let sequencer_client =
             SequencerClient::new(sequencer_url).context("Failed to create sequencer client")?;
+        let indexer_client = IndexerClient::new(&indexer_url)
+            .await
+            .context("Failed to create indexer client")?;
 
         Ok(Self {
             sequencer_client,
+            indexer_client,
             wallet,
             bedrock_compose,
             sequencer_handle,
             indexer_handle,
+            _temp_indexer_dir: temp_indexer_dir,
             _temp_sequencer_dir: temp_sequencer_dir,
             _temp_wallet_dir: temp_wallet_dir,
         })
@@ -158,13 +168,26 @@ impl TestContext {
         Ok((compose, addr))
     }
 
-    async fn setup_indexer(bedrock_addr: SocketAddr) -> Result<IndexerHandle> {
-        let indexer_config =
-            config::indexer_config(bedrock_addr).context("Failed to create Indexer config")?;
+    async fn setup_indexer(
+        bedrock_addr: SocketAddr,
+        initial_data: &config::InitialData,
+    ) -> Result<(IndexerHandle, TempDir)> {
+        let temp_indexer_dir =
+            tempfile::tempdir().context("Failed to create temp dir for indexer home")?;
+
+        debug!("Using temp indexer home at {:?}", temp_indexer_dir.path());
+
+        let indexer_config = config::indexer_config(
+            bedrock_addr,
+            temp_indexer_dir.path().to_owned(),
+            initial_data,
+        )
+        .context("Failed to create Indexer config")?;
 
         indexer_service::run_server(indexer_config, 0)
             .await
             .context("Failed to run Indexer Service")
+            .map(|handle| (handle, temp_indexer_dir))
     }
 
     async fn setup_sequencer(
@@ -245,6 +268,11 @@ impl TestContext {
         &self.sequencer_client
     }
 
+    /// Get reference to the indexer client.
+    pub fn indexer_client(&self) -> &IndexerClient {
+        &self.indexer_client
+    }
+
     /// Get existing public account IDs in the wallet.
     pub fn existing_public_accounts(&self) -> Vec<AccountId> {
         self.wallet
@@ -270,9 +298,11 @@ impl Drop for TestContext {
             sequencer_handle,
             indexer_handle,
             bedrock_compose,
+            _temp_indexer_dir: _,
             _temp_sequencer_dir: _,
             _temp_wallet_dir: _,
             sequencer_client: _,
+            indexer_client: _,
             wallet: _,
         } = self;
 

integration_tests/tests/indexer.rs

@@ -0,0 +1,36 @@
+use anyhow::Result;
+use indexer_service_rpc::RpcClient;
+use integration_tests::TestContext;
+use log::info;
+use tokio::test;
+// use wallet::cli::{Command, config::ConfigSubcommand};
+
+#[test]
+async fn indexer_test_run() -> Result<()> {
+    let ctx = TestContext::new().await?;
+
+    // RUN OBSERVATION
+    info!("LETS TAKE A LOOK");
+    tokio::time::sleep(std::time::Duration::from_secs(100)).await;
+
+    let last_block_seq = ctx
+        .sequencer_client()
+        .get_last_block()
+        .await
+        .unwrap()
+        .last_block;
+
+    info!("Last block on seq now is {last_block_seq}");
+
+    let last_block_indexer = ctx
+        .indexer_client()
+        .get_last_finalized_block_id()
+        .await
+        .unwrap();
+
+    info!("Last block on ind now is {last_block_indexer}");
+
+    assert!(last_block_indexer > 1);
+
+    Ok(())
+}

integration_tests/tests/token.rs

@@ -639,7 +639,6 @@ async fn create_token_with_private_definition_and_supply() -> Result<()> {
     };
 
     // Create token with both private definition and supply
-    let name = "A NAME".to_string();
     let total_supply = 37;
     let subcommand = TokenProgramAgnosticSubcommand::New {
         definition_account_id: format_private_account_id(definition_account_id),
@@ -799,7 +798,6 @@ async fn shielded_token_transfer() -> Result<()> {
     };
 
     // Create token
-    let name = "A NAME".to_string();
     let total_supply = 37;
     let subcommand = TokenProgramAgnosticSubcommand::New {
         definition_account_id: format_public_account_id(definition_account_id),
@@ -913,7 +911,6 @@ async fn deshielded_token_transfer() -> Result<()> {
     };
 
     // Create token with private supply
-    let name = "A NAME".to_string();
     let total_supply = 37;
     let subcommand = TokenProgramAgnosticSubcommand::New {
         definition_account_id: format_public_account_id(definition_account_id),
@@ -1014,8 +1011,6 @@ async fn token_claiming_path_with_private_accounts() -> Result<()> {
     };
 
     // Create token
-    let name = "A NAME".to_string();
-    let total_supply = 37;
     let subcommand = TokenProgramAgnosticSubcommand::New {
         definition_account_id: format_private_account_id(definition_account_id),
         supply_account_id: format_private_account_id(supply_account_id),