fix for no-code panic bug (#408)

Author: masonhgn

core/src/event/callback_registry.rs

@@ -46,6 +46,32 @@ pub enum CallbackResult {
     Trace(Vec<TraceResult>),
 }
 
+impl CallbackResult {
+    /// return the (from_block, to_block, network) entry regardless of variant
+    pub fn first_metadata(&self) -> Option<(U64, U64, String)> {
+        match self {
+            Self::Event(events) => events.first().map(|e| {
+                (
+                    e.found_in_request.from_block,
+                    e.found_in_request.to_block,
+                    e.tx_information.network.clone(),
+                )
+            }),
+            Self::Trace(traces) => traces.first().map(|t| {
+                let (fir, tx) = match t {
+                    TraceResult::NativeTransfer { found_in_request, tx_information, .. } => {
+                        (found_in_request, tx_information)
+                    }
+                    TraceResult::Block { found_in_request, tx_information, .. } => {
+                        (found_in_request, tx_information)
+                    }
+                };
+                (fir.from_block, fir.to_block, tx.network.clone())
+            }),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct TxInformation {
     pub chain_id: u64,
@@ -507,3 +533,128 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy::network::AnyRpcBlock;
+
+    fn test_tx_information(network: &str) -> TxInformation {
+        TxInformation {
+            chain_id: 31337,
+            network: network.to_string(),
+            address: Address::ZERO,
+            block_hash: BlockHash::ZERO,
+            block_number: 0,
+            block_timestamp: None,
+            transaction_hash: TxHash::ZERO,
+            transaction_index: 0,
+            log_index: U256::ZERO,
+        }
+    }
+
+    fn test_found_in_request(from_block: u64, to_block: u64) -> LogFoundInRequest {
+        LogFoundInRequest { from_block: U64::from(from_block), to_block: U64::from(to_block) }
+    }
+
+    //Minimal valid json for alloy::network::AnyRpcBlock deserialization
+    const TEST_BLOCK_JSON: &str = r#"{
+        "number": "0x0",
+        "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "transactionsRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "receiptsRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "miner": "0x0000000000000000000000000000000000000000",
+        "difficulty": "0x0",
+        "extraData": "0x",
+        "size": "0x0",
+        "gasLimit": "0x0",
+        "gasUsed": "0x0",
+        "timestamp": "0x0",
+        "transactions": [],
+        "uncles": []
+    }"#;
+
+    const TEST_LOG_JSON: &str = r#"{
+        "address": "0x0000000000000000000000000000000000000000",
+        "topics": [],
+        "data": "0x",
+        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "blockNumber": "0x0",
+        "transactionHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "transactionIndex": "0x0",
+        "logIndex": "0x0",
+        "removed": false
+    }"#;
+
+    fn test_block() -> AnyRpcBlock {
+        serde_json::from_str(TEST_BLOCK_JSON).expect("test block JSON should deserialize")
+    }
+
+    fn test_log() -> Log {
+        serde_json::from_str(TEST_LOG_JSON).expect("test log JSON should deserialize")
+    }
+
+    #[test]
+    fn first_metadata_event_returns_fields_from_first_entry() {
+        let event = EventResult {
+            log: test_log(),
+            decoded_data: Arc::new(()),
+            tx_information: test_tx_information("mainnet"),
+            found_in_request: test_found_in_request(10, 20),
+        };
+        let result = CallbackResult::Event(vec![event]);
+        let (from_block, to_block, network) = result.first_metadata().expect("non-empty batch");
+        assert_eq!(from_block, U64::from(10));
+        assert_eq!(to_block, U64::from(20));
+        assert_eq!(network, "mainnet");
+    }
+
+    #[test]
+    fn first_metadata_trace_native_transfer_returns_fields() {
+        let nt = TraceResult::NativeTransfer {
+            from: Address::ZERO,
+            to: Address::ZERO,
+            value: U256::ZERO,
+            tx_information: test_tx_information("anvil"),
+            found_in_request: test_found_in_request(5, 15),
+        };
+        let result = CallbackResult::Trace(vec![nt]);
+        let (from_block, to_block, network) = result.first_metadata().expect("non-empty batch");
+        assert_eq!(from_block, U64::from(5));
+        assert_eq!(to_block, U64::from(15));
+        assert_eq!(network, "anvil");
+    }
+
+    //native_transfer_block_consumer always fires trigger_event with a Block-only batch before firing the
+    // NativeTransfer batch, so first_metadata must
+    // extract cleanly from a TraceResult::Block without panicking
+    #[test]
+    fn first_metadata_trace_block_returns_fields() {
+        let b = TraceResult::Block {
+            block: Box::new(test_block()),
+            tx_information: test_tx_information("polygon"),
+            found_in_request: test_found_in_request(100, 200),
+        };
+        let result = CallbackResult::Trace(vec![b]);
+        let (from_block, to_block, network) = result.first_metadata().expect("non-empty batch");
+        assert_eq!(from_block, U64::from(100));
+        assert_eq!(to_block, U64::from(200));
+        assert_eq!(network, "polygon");
+    }
+
+    #[test]
+    fn first_metadata_empty_event_returns_none() {
+        let result = CallbackResult::Event(vec![]);
+        assert!(result.first_metadata().is_none());
+    }
+
+    #[test]
+    fn first_metadata_empty_trace_returns_none() {
+        let result = CallbackResult::Trace(vec![]);
+        assert!(result.first_metadata().is_none());
+    }
+}

core/src/indexer/no_code.rs

@@ -338,48 +338,9 @@ fn no_code_callback(params: Arc<NoCodeCallbackParams>) -> EventCallbacks {
                 return Ok(());
             }
 
-            // TODO
-            // Remove unwrap
-            let (from_block, to_block) = match &results {
-                CallbackResult::Event(event) => (
-                    event.first().unwrap().found_in_request.from_block,
-                    event.first().unwrap().found_in_request.to_block,
-                ),
-                CallbackResult::Trace(event) => {
-                    // Filter to only NativeTransfer events and get the first one
-                    let native_transfer = event
-                        .iter()
-                        .filter_map(|result| match result {
-                            TraceResult::NativeTransfer { found_in_request, .. } => {
-                                Some(found_in_request)
-                            }
-                            TraceResult::Block { .. } => None,
-                        })
-                        .next()
-                        .unwrap();
-                    (native_transfer.from_block, native_transfer.to_block)
-                }
-            };
-
-            let network = match &results {
-                CallbackResult::Event(event) => {
-                    event.first().unwrap().tx_information.network.clone()
-                }
-                CallbackResult::Trace(event) => {
-                    // Filter to only NativeTransfer events and get the first one
-                    event
-                        .iter()
-                        .filter_map(|result| match result {
-                            TraceResult::NativeTransfer { tx_information, .. } => {
-                                Some(&tx_information.network)
-                            }
-                            TraceResult::Block { .. } => None,
-                        })
-                        .next()
-                        .unwrap()
-                        .clone()
-                }
-            };
+            //guarantees non empty batch
+            let (from_block, to_block, network) =
+                results.first_metadata().expect("event_length > 0 guarantees at least one entry");
 
             let mut indexed_count = 0;
             let mut sql_bulk_data: Vec<Vec<EthereumSqlTypeWrapper>> = Vec::new();

e2e-tests/src/anvil_setup.rs

@@ -360,6 +360,43 @@ impl AnvilInstance {
         Ok(tx_hashes)
     }
 
+    ///send plain eth transfer
+    pub async fn send_eth_transfer(
+        &self,
+        to: &ethers::types::Address,
+        amount: ethers::types::U256,
+    ) -> Result<String> {
+        use ethers::middleware::MiddlewareBuilder;
+        use ethers::providers::{Http, Middleware, Provider};
+        use ethers::signers::{LocalWallet, Signer};
+        use ethers::types::TransactionRequest;
+
+        let base_provider = Provider::<Http>::try_from(&self.rpc_url)?;
+        let chain_id = base_provider.get_chainid().await?.as_u64();
+
+        let wallet: LocalWallet = ANVIL_DEFAULT_PRIVATE_KEY.parse()?;
+        let wallet = wallet.with_chain_id(chain_id);
+        let signer_address = wallet.address();
+        let provider = base_provider.with_signer(wallet);
+
+        let nonce = provider.get_transaction_count(signer_address, None).await?;
+
+        let tx = TransactionRequest {
+            from: Some(signer_address),
+            to: Some((*to).into()),
+            data: None,
+            gas: Some(21000u64.into()),
+            nonce: Some(nonce),
+            gas_price: Some(20000000000u128.into()),
+            value: Some(amount),
+            chain_id: None,
+        };
+
+        let pending = provider.send_transaction(tx, None).await?;
+        let tx_hash = format!("{:?}", pending.tx_hash()).to_lowercase();
+        Ok(tx_hash)
+    }
+
     /// Get transaction receipt.
     #[allow(dead_code)]
     pub async fn get_receipt(&self, tx_hash: &str) -> Result<TxReceipt> {

e2e-tests/src/rindexer_client.rs

@@ -422,7 +422,11 @@ impl RindexerInstance {
                 csv: crate::test_suite::CsvConfig { enabled: true },
                 clickhouse: None,
             },
-            native_transfers: crate::test_suite::NativeTransfersConfig { enabled: false },
+            native_transfers: crate::test_suite::NativeTransfersConfig {
+                enabled: false,
+                networks: None,
+                generate_csv: None,
+            },
             contracts: vec![],
         }
     }

e2e-tests/src/test_suite.rs

@@ -71,6 +71,19 @@ pub struct CsvConfig {
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct NativeTransfersConfig {
     pub enabled: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub networks: Option<Vec<NativeTransferNetworkDetail>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub generate_csv: Option<bool>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct NativeTransferNetworkDetail {
+    pub network: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub start_block: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end_block: Option<String>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]

e2e-tests/src/tests/direct_rpc.rs

@@ -111,7 +111,11 @@ fn build_direct_rpc_config(
             csv: CsvConfig { enabled: true },
             clickhouse: None,
         },
-        native_transfers: NativeTransfersConfig { enabled: false },
+        native_transfers: NativeTransfersConfig {
+            enabled: false,
+            networks: None,
+            generate_csv: None,
+        },
         contracts: vec![ContractConfig {
             name: "ERC20".to_string(),
             details: vec![ContractDetail {

e2e-tests/src/tests/mod.rs

@@ -10,6 +10,7 @@ pub mod health_assertions;
 pub mod historic_indexing;
 pub mod live_indexing;
 pub mod multi_network;
+pub mod native_transfer;
 pub mod postgres_e2e;
 pub mod reorg_e2e;
 pub mod restart_checkpoint;

e2e-tests/src/tests/multi_network.rs

@@ -268,7 +268,11 @@ fn build_multi_network_config(
             csv: CsvConfig { enabled: true },
             clickhouse: None,
         },
-        native_transfers: NativeTransfersConfig { enabled: false },
+        native_transfers: NativeTransfersConfig {
+            enabled: false,
+            networks: None,
+            generate_csv: None,
+        },
         contracts: vec![
             ContractConfig {
                 name: "RocketPoolETH".to_string(),