cleanup typos, commented out code and minor refactoring

Author: incrypto32

chain/ethereum/src/runtime/abi.rs

@@ -595,7 +595,7 @@ where
     EthereumTransactionData<'a>: ToAscObj<T>,
     EthereumBlockData<'a>: ToAscObj<B>,
     Inner: Send + Sync,
-    for<'b> &'b TransactionReceipt<Inner>: ToAscObj<AscEthereumTransactionReceipt>,
+    TransactionReceipt<Inner>: ToAscObj<AscEthereumTransactionReceipt>,
 {
     fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
@@ -673,51 +673,8 @@ impl ToAscObj<AscEthereumLog> for Log {
     }
 }
 
-impl ToAscObj<AscEthereumTransactionReceipt> for &alloy::rpc::types::TransactionReceipt {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscEthereumTransactionReceipt, HostExportError> {
-        Ok(AscEthereumTransactionReceipt {
-            transaction_hash: asc_new(heap, &self.transaction_hash, gas)?,
-            transaction_index: asc_new(
-                heap,
-                &BigInt::from(
-                    self.transaction_index
-                        .ok_or(HostExportError::Unknown(anyhow!(
-                            "Transaction index is missing"
-                        )))?,
-                ),
-                gas,
-            )?,
-            block_hash: self
-                .block_hash
-                .map(|block_hash| asc_new(heap, &block_hash, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            block_number: self
-                .block_number
-                .map(|block_number| asc_new(heap, &BigInt::from(block_number), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            cumulative_gas_used: asc_new(heap, &BigInt::from(self.gas_used), gas)?,
-            gas_used: asc_new(heap, &BigInt::from(self.gas_used), gas)?,
-            contract_address: self
-                .contract_address
-                .map(|contract_address| asc_new(heap, &contract_address, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            logs: asc_new(heap, &self.logs(), gas)?,
-            status: asc_new(heap, &BigInt::from(self.status() as u64), gas)?,
-            root: self
-                .state_root()
-                .map(|root| asc_new(heap, &root, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            logs_bloom: asc_new(heap, self.inner.logs_bloom().as_slice(), gas)?,
-        })
-    }
-}
-
 impl ToAscObj<AscEthereumTransactionReceipt>
-    for &TransactionReceipt<alloy::network::AnyReceiptEnvelope<Log>>
+    for TransactionReceipt<alloy::network::AnyReceiptEnvelope<Log>>
 {
     fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,

graph/src/components/transaction_receipt.rs

@@ -5,7 +5,6 @@
 
 use alloy::network::ReceiptResponse;
 use alloy::primitives::B256;
-use alloy::rpc::types::TransactionReceipt;
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct LightTransactionReceipt {
@@ -17,19 +16,6 @@ pub struct LightTransactionReceipt {
     pub status: bool,
 }
 
-impl From<TransactionReceipt> for LightTransactionReceipt {
-    fn from(receipt: alloy::rpc::types::TransactionReceipt) -> Self {
-        LightTransactionReceipt {
-            transaction_hash: receipt.transaction_hash,
-            transaction_index: receipt.transaction_index.unwrap(),
-            block_hash: receipt.block_hash,
-            block_number: receipt.block_number,
-            gas_used: receipt.gas_used,
-            status: receipt.status(),
-        }
-    }
-}
-
 impl From<alloy::network::AnyTransactionReceipt> for LightTransactionReceipt {
     fn from(receipt: alloy::network::AnyTransactionReceipt) -> Self {
         LightTransactionReceipt {

graph/src/lib.rs

@@ -41,7 +41,6 @@ pub mod abi;
 
 /// Wrapper for spawning tasks that abort on panic, which is our default.
 mod task_spawn;
-
 pub use task_spawn::{
     block_on, spawn, spawn_allow_panic, spawn_blocking, spawn_blocking_allow_panic, spawn_thread,
 };

node/src/manager/commands/chain.rs

@@ -280,7 +280,7 @@ pub async fn ingest(
     let number = block.header.number;
     // For inserting the block, it doesn't matter whether the block is final or not.
     let block = Arc::new(BlockFinality::Final(Arc::new(LightEthereumBlock::new(
-        block.into(),
+        block,
     ))));
     chain_store.upsert_block(block).await?;
 

store/postgres/src/chain_store.rs

@@ -169,7 +169,7 @@ mod data {
         hash: Vec<u8>,
     }
 
-    // Like H256::from_slice, but returns an error instead of panicking
+    // Like B256::from_slice, but returns an error instead of panicking
     // when `bytes` does not have the right length
     fn b256_from_bytes(bytes: &[u8]) -> Result<B256, StoreError> {
         if bytes.len() == B256::len_bytes() {

store/postgres/src/deployment.rs

@@ -22,15 +22,14 @@ use graph::{
     slog::{debug, Logger},
 };
 use graph::{components::store::StoreResult, semver::Version};
-use graph::{
-    data::store::scalar::ToPrimitive,
-    prelude::{anyhow, hex, BlockNumber, BlockPtr, DeploymentHash, DeploymentState, StoreError},
-    schema::InputSchema,
-};
 use graph::{
     data::subgraph::schema::{DeploymentCreate, SubgraphManifestEntity},
     util::backoff::ExponentialBackoff,
 };
+use graph::{
+    prelude::{anyhow, hex, BlockNumber, BlockPtr, DeploymentHash, DeploymentState, StoreError},
+    schema::InputSchema,
+};
 use stable_hash_legacy::crypto::SetHasher;
 use std::sync::Arc;
 use std::{convert::TryFrom, ops::Bound, time::Duration};
@@ -261,14 +260,13 @@ fn graft(
             //
             // workaround for arweave
             let hash = B256::from_slice(&hash.as_slice()[..32]);
-            let block = block.to_u64().expect("block numbers fit into a u64");
             let subgraph = DeploymentHash::new(subgraph.clone()).map_err(|_| {
                 StoreError::Unknown(anyhow!(
                     "the base subgraph for a graft must be a valid subgraph id but is `{}`",
                     subgraph
                 ))
             })?;
-            Ok(Some((subgraph, BlockPtr::from((hash, block as i32)))))
+            Ok(Some((subgraph, BlockPtr::from((hash, block)))))
         }
         _ => unreachable!(
             "graftBlockHash and graftBlockNumber are either both set or neither is set"

tests/src/fixture/ethereum.rs

@@ -79,12 +79,10 @@ pub async fn chain(
 }
 
 pub fn genesis() -> BlockWithTriggers<graph_chain_ethereum::Chain> {
-    #[allow(unused_variables)]
     let ptr = test_ptr(0);
 
     let block = create_minimal_block_for_test(ptr.number as u64, ptr.hash.as_b256());
 
-    #[allow(unreachable_code)]
     BlockWithTriggers::<graph_chain_ethereum::Chain> {
         block: BlockFinality::Final(Arc::new(LightEthereumBlock::new(block.into()))),
         trigger_data: vec![Trigger::Chain(EthereumTrigger::Block(

tests/tests/integration_tests.rs

@@ -16,15 +16,14 @@ use std::time::{self, Duration, Instant};
 use anyhow::{anyhow, bail, Context, Result};
 use graph::futures03::StreamExt;
 use graph::itertools::Itertools;
-use graph::prelude::alloy::primitives::U256;
 use graph::prelude::serde_json::{json, Value};
 use graph_tests::contract::Contract;
 use graph_tests::subgraph::Subgraph;
 use graph_tests::{error, status, CONFIG};
 use tokio::process::Child;
 use tokio::task::JoinError;
 use tokio::time::sleep;
-use web3;
+use web3::types::U256;
 
 const SUBGRAPH_LAST_GRAFTING_BLOCK: i32 = 3;
 
@@ -635,10 +634,6 @@ pub async fn subgraph_data_sources(ctx: TestContext) -> anyhow::Result<()> {
     Ok(())
 }
 
-fn alloy_u256_to_web3_u256(u: U256) -> web3::types::U256 {
-    web3::types::U256::from_little_endian(u.as_le_slice())
-}
-
 async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
     let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
@@ -653,9 +648,9 @@ async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
         .call(
             "emitAnotherTrigger",
             (
-                alloy_u256_to_web3_u256(U256::from(1)),
-                alloy_u256_to_web3_u256(U256::from(2)),
-                alloy_u256_to_web3_u256(U256::from(3)),
+                U256::from(1),
+                U256::from(2),
+                U256::from(3),
                 "abc".to_string(),
             ),
         )
@@ -666,9 +661,9 @@ async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
         .call(
             "emitAnotherTrigger",
             (
-                alloy_u256_to_web3_u256(U256::from(1)),
-                alloy_u256_to_web3_u256(U256::from(1)),
-                alloy_u256_to_web3_u256(U256::from(1)),
+                U256::from(1),
+                U256::from(1),
+                U256::from(1),
                 "abc".to_string(),
             ),
         )
@@ -679,9 +674,9 @@ async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
         .call(
             "emitAnotherTrigger",
             (
-                alloy_u256_to_web3_u256(U256::from(4)),
-                alloy_u256_to_web3_u256(U256::from(2)),
-                alloy_u256_to_web3_u256(U256::from(3)),
+                U256::from(4),
+                U256::from(2),
+                U256::from(3),
                 "abc".to_string(),
             ),
         )
@@ -692,9 +687,9 @@ async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
         .call(
             "emitAnotherTrigger",
             (
-                alloy_u256_to_web3_u256(U256::from(4)),
-                alloy_u256_to_web3_u256(U256::from(4)),
-                alloy_u256_to_web3_u256(U256::from(3)),
+                U256::from(4),
+                U256::from(4),
+                U256::from(3),
                 "abc".to_string(),
             ),
         )