core,graph,runtime: Create FullBlock struct and pass to mappings

Author: fordN

graph/src/components/ethereum/adapter.rs

@@ -411,6 +411,7 @@ impl From<EthereumBlockFilter> for EthereumCallFilter {
 pub struct EthereumBlockFilter {
     pub contract_addresses: HashSet<(u64, Address)>,
     pub trigger_every_block: bool,
+    pub full_block: bool,
 }
 
 impl EthereumBlockFilter {
@@ -435,8 +436,10 @@ impl EthereumBlockFilter {
                     .into_iter()
                     .any(|block_handler| block_handler.filter.is_none());
 
+                // TODO: process data source to get full_block boolean
                 filter_opt.extend(Self {
                     trigger_every_block: has_block_handler_without_filter,
+                    full_block: true,
                     contract_addresses: if has_block_handler_with_call_filter {
                         vec![(
                             data_source.source.start_block,
@@ -816,7 +819,7 @@ fn parse_block_triggers(
     if trigger_every_block {
         triggers.push(EthereumTrigger::Block(
             block_ptr,
-            EthereumBlockTriggerType::Every,
+            EthereumBlockTriggerType::Every(BlockType::Full),
         ));
     }
     triggers
@@ -921,7 +924,12 @@ pub fn blocks_with_triggers(
                 .block_range_to_ptrs(logger.clone(), from, to)
                 .map(move |ptrs| {
                     ptrs.into_iter()
-                        .map(|ptr| EthereumTrigger::Block(ptr, EthereumBlockTriggerType::Every))
+                        .map(|ptr| {
+                            EthereumTrigger::Block(
+                                ptr,
+                                EthereumBlockTriggerType::Every(BlockType::Full),
+                            )
+                        })
                         .collect()
                 }),
         ))

graph/src/components/ethereum/mod.rs

@@ -13,8 +13,8 @@ pub use self::adapter::{
 pub use self::listener::{ChainHeadUpdate, ChainHeadUpdateListener, ChainHeadUpdateStream};
 pub use self::stream::{BlockStream, BlockStreamBuilder, BlockStreamEvent};
 pub use self::types::{
-    BlockFinality, EthereumBlock, EthereumBlockData, EthereumBlockPointer,
+    EthereumBlockType, BlockFinality, BlockType, EthereumBlock, EthereumBlockData, EthereumBlockPointer,
     EthereumBlockTriggerType, EthereumBlockWithCalls, EthereumBlockWithTriggers, EthereumCall,
-    EthereumCallData, EthereumEventData, EthereumTransactionData, EthereumTrigger,
-    LightEthereumBlock, LightEthereumBlockExt,
+    EthereumCallData, EthereumEventData, EthereumTransactionData, EthereumTransactionReceiptData,
+    EthereumTrigger, FullEthereumBlockData, LightEthereumBlock, LightEthereumBlockExt,
 };

graph/src/components/ethereum/types.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 use stable_hash::prelude::*;
 use stable_hash::utils::AsBytes;
 use std::cmp::Ordering;
+use std::convert::TryFrom;
 use std::fmt;
 use web3::types::*;
 
@@ -56,6 +57,15 @@ impl LightEthereumBlockExt for LightEthereumBlock {
     }
 }
 
+impl<'a> From<&'a EthereumBlockType> for LightEthereumBlock {
+    fn from(block: &'a EthereumBlockType) -> LightEthereumBlock {
+        match block {
+            EthereumBlockType::Full(block) => block.block.clone(),
+            EthereumBlockType::Light(block) => block.clone(),
+        }
+    }
+}
+
 /// This is used in `EthereumAdapter::triggers_in_block`, called when re-processing a block for
 /// newly created data sources. This allows the re-processing to be reorg safe without having to
 /// always fetch the full block data.
@@ -193,9 +203,37 @@ impl PartialEq for EthereumTrigger {
 
 impl Eq for EthereumTrigger {}
 
+/// This is used in `EthereumAdapter::triggers_in_block`, called when re-processing a block for
+/// newly created data sources. This allows the re-processing to be reorg safe without having to
+/// always fetch the full block data.
+#[derive(Clone, Debug)]
+pub enum EthereumBlockType {
+    Light(LightEthereumBlock),
+
+    Full(EthereumBlock),
+}
+
+impl Default for EthereumBlockType {
+    fn default() -> Self {
+        EthereumBlockType::Light(LightEthereumBlock::default())
+    }
+}
+
+impl<'a> From<&'a LightEthereumBlock> for EthereumBlockType {
+    fn from(block: &'a LightEthereumBlock) -> EthereumBlockType {
+        EthereumBlockType::Light(block.clone())
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum BlockType {
+    Light,
+    Full,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum EthereumBlockTriggerType {
-    Every,
+    Every(BlockType),
     WithCallTo(Address),
 }
 
@@ -263,6 +301,158 @@ impl PartialOrd for EthereumTrigger {
     }
 }
 
+pub struct EthereumTransactionReceiptData {
+    // from receipts
+    pub transaction_hash: H256,
+    pub transaction_index: Index,
+    pub cumulative_gas_used: U256,
+    pub gas_used: Option<U256>,
+    pub contract_address: Option<H160>,
+    pub status: Option<U64>,
+    pub root: Option<H256>,
+
+    // from txs
+    pub from: H160,
+    pub to: Option<H160>,
+    pub value: U256,
+    pub gas_price: U256,
+    pub gas: U256,
+    pub input: Bytes,
+}
+
+pub struct FullEthereumBlockData {
+    pub hash: H256,
+    pub parent_hash: H256,
+    pub uncles_hash: H256,
+    pub author: H160,
+    pub state_root: H256,
+    pub transactions_root: H256,
+    pub receipts_root: H256,
+    pub number: U64,
+    pub gas_used: U256,
+    pub gas_limit: U256,
+    pub timestamp: U256,
+    pub difficulty: U256,
+    pub total_difficulty: U256,
+    pub size: Option<U256>,
+    pub transaction_receipts: Vec<EthereumTransactionReceiptData>,
+}
+
+impl<'a> TryFrom<&'a EthereumBlockType> for FullEthereumBlockData {
+    type Error = String;
+
+    fn try_from(block: &'a EthereumBlockType) -> Result<FullEthereumBlockData, Self::Error> {
+        let fullblock = match block {
+            EthereumBlockType::Full(full_block) => full_block,
+            EthereumBlockType::Light(_) => return Err(format!(
+                "Failed to convert EthereumBlockType to FUllEthereumBlockData, requires a EthereumBlockType::Full()"
+            ))
+        };
+        let block = &fullblock.block;
+        let transaction_receipts_data = block
+            .transactions
+            .iter()
+            .cloned()
+            .zip(fullblock.transaction_receipts.iter().cloned())
+            .map(|transaction_and_receipt| {
+                assert_eq!(
+                    transaction_and_receipt.0.hash,
+                    transaction_and_receipt.1.transaction_hash
+                );
+                EthereumTransactionReceiptData {
+                    transaction_hash: transaction_and_receipt.0.hash,
+                    transaction_index: transaction_and_receipt.1.transaction_index,
+                    cumulative_gas_used: transaction_and_receipt.1.cumulative_gas_used,
+                    gas_used: transaction_and_receipt.1.gas_used,
+                    contract_address: transaction_and_receipt.1.contract_address,
+                    status: transaction_and_receipt.1.status,
+                    root: transaction_and_receipt.1.root,
+
+                    // from txs
+                    from: transaction_and_receipt.0.from,
+                    to: transaction_and_receipt.0.to,
+                    value: transaction_and_receipt.0.value,
+                    gas_price: transaction_and_receipt.0.gas_price,
+                    gas: transaction_and_receipt.0.gas,
+                    input: transaction_and_receipt.0.input,
+                }
+            })
+            .collect::<Vec<EthereumTransactionReceiptData>>();
+
+        Ok(FullEthereumBlockData {
+            hash: block.hash.unwrap(),
+            parent_hash: block.parent_hash,
+            uncles_hash: block.uncles_hash,
+            author: block.author,
+            state_root: block.state_root,
+            transactions_root: block.transactions_root,
+            receipts_root: block.receipts_root,
+            number: block.number.unwrap(),
+            gas_used: block.gas_used,
+            gas_limit: block.gas_limit,
+            timestamp: block.timestamp,
+            difficulty: block.difficulty,
+            total_difficulty: block.total_difficulty.unwrap_or_default(),
+            size: block.size,
+            transaction_receipts: transaction_receipts_data,
+        })
+    }
+}
+
+impl<'a> From<&'a EthereumBlock> for FullEthereumBlockData {
+    fn from(block: &'a EthereumBlock) -> FullEthereumBlockData {
+        let transaction_receipts_data = block
+            .block
+            .transactions
+            .iter()
+            .cloned()
+            .zip(block.transaction_receipts.iter().cloned())
+            .map(|transaction_and_receipt| {
+                assert_eq!(
+                    transaction_and_receipt.0.hash,
+                    transaction_and_receipt.1.transaction_hash
+                );
+                EthereumTransactionReceiptData {
+                    transaction_hash: transaction_and_receipt.0.hash,
+                    transaction_index: transaction_and_receipt.1.transaction_index,
+                    cumulative_gas_used: transaction_and_receipt.1.cumulative_gas_used,
+                    gas_used: transaction_and_receipt.1.gas_used,
+                    contract_address: transaction_and_receipt.1.contract_address,
+                    status: transaction_and_receipt.1.status,
+                    root: transaction_and_receipt.1.root,
+
+                    // from txs
+                    from: transaction_and_receipt.0.from,
+                    to: transaction_and_receipt.0.to,
+                    value: transaction_and_receipt.0.value,
+                    gas_price: transaction_and_receipt.0.gas_price,
+                    gas: transaction_and_receipt.0.gas,
+                    input: transaction_and_receipt.0.input,
+                }
+            })
+            .collect::<Vec<EthereumTransactionReceiptData>>();
+        let block = &block.block;
+
+        FullEthereumBlockData {
+            hash: block.hash.unwrap(),
+            parent_hash: block.parent_hash,
+            uncles_hash: block.uncles_hash,
+            author: block.author,
+            state_root: block.state_root,
+            transactions_root: block.transactions_root,
+            receipts_root: block.receipts_root,
+            number: block.number.unwrap(),
+            gas_used: block.gas_used,
+            gas_limit: block.gas_limit,
+            timestamp: block.timestamp,
+            difficulty: block.difficulty,
+            total_difficulty: block.total_difficulty.unwrap_or_default(),
+            size: block.size,
+            transaction_receipts: transaction_receipts_data,
+        }
+    }
+}
+
 /// Ethereum block data.
 #[derive(Clone, Debug, Default)]
 pub struct EthereumBlockData {
@@ -303,6 +493,32 @@ impl<'a, T> From<&'a Block<T>> for EthereumBlockData {
     }
 }
 
+impl<'a> From<&'a EthereumBlockType> for EthereumBlockData {
+    fn from(block: &'a EthereumBlockType) -> EthereumBlockData {
+        let block = match block {
+            EthereumBlockType::Full(full_block) => &full_block.block,
+            EthereumBlockType::Light(light_block) => light_block,
+        };
+
+        EthereumBlockData {
+            hash: block.hash.unwrap(),
+            parent_hash: block.parent_hash,
+            uncles_hash: block.uncles_hash,
+            author: block.author,
+            state_root: block.state_root,
+            transactions_root: block.transactions_root,
+            receipts_root: block.receipts_root,
+            number: block.number.unwrap(),
+            gas_used: block.gas_used,
+            gas_limit: block.gas_limit,
+            timestamp: block.timestamp,
+            difficulty: block.difficulty,
+            total_difficulty: block.total_difficulty.unwrap_or_default(),
+            size: block.size,
+        }
+    }
+}
+
 /// Ethereum transaction data.
 #[derive(Clone, Debug)]
 pub struct EthereumTransactionData {
@@ -536,7 +752,9 @@ impl ToEntityKey for EthereumBlockPointer {
 
 #[cfg(test)]
 mod test {
-    use super::{EthereumBlockPointer, EthereumBlockTriggerType, EthereumCall, EthereumTrigger};
+    use super::{
+        BlockType, EthereumBlockPointer, EthereumBlockTriggerType, EthereumCall, EthereumTrigger,
+    };
     use web3::types::*;
 
     #[test]
@@ -546,7 +764,7 @@ mod test {
                 number: 1,
                 hash: H256::random(),
             },
-            EthereumBlockTriggerType::Every,
+            EthereumBlockTriggerType::Every(BlockType::Light),
         );
 
         let block2 = EthereumTrigger::Block(

graph/src/lib.rs

@@ -80,8 +80,8 @@ pub mod prelude {
         EthereumBlockPointer, EthereumBlockTriggerType, EthereumBlockWithCalls,
         EthereumBlockWithTriggers, EthereumCall, EthereumCallData, EthereumCallFilter,
         EthereumContractCall, EthereumContractCallError, EthereumEventData, EthereumLogFilter,
-        EthereumNetworkIdentifier, EthereumTransactionData, EthereumTrigger, LightEthereumBlock,
-        LightEthereumBlockExt, ProviderEthRpcMetrics, SubgraphEthRpcMetrics,
+        EthereumNetworkIdentifier, EthereumTransactionData, EthereumTrigger, FullEthereumBlockData,
+        LightEthereumBlock, LightEthereumBlockExt, ProviderEthRpcMetrics, SubgraphEthRpcMetrics,
     };
     pub use crate::components::graphql::{
         GraphQlRunner, QueryResultFuture, SubscriptionResultFuture,

runtime/wasm/src/asc_abi/class.rs

@@ -418,6 +418,26 @@ pub(crate) struct AscEthereumBlock {
     pub size: AscPtr<AscBigInt>,
 }
 
+#[repr(C)]
+#[derive(AscType)]
+pub(crate) struct AscFullEthereumBlock {
+    pub hash: AscPtr<AscH256>,
+    pub parent_hash: AscPtr<AscH256>,
+    pub uncles_hash: AscPtr<AscH256>,
+    pub author: AscPtr<AscH160>,
+    pub state_root: AscPtr<AscH256>,
+    pub transactions_root: AscPtr<AscH256>,
+    pub receipts_root: AscPtr<AscH256>,
+    pub number: AscPtr<AscBigInt>,
+    pub gas_used: AscPtr<AscBigInt>,
+    pub gas_limit: AscPtr<AscBigInt>,
+    pub timestamp: AscPtr<AscBigInt>,
+    pub difficulty: AscPtr<AscBigInt>,
+    pub total_difficulty: AscPtr<AscBigInt>,
+    pub size: AscPtr<AscBigInt>,
+    pub transaction_receipts: AscPtr<Array<AscPtr<AscEthereumTransactionReceipt>>>,
+}
+
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscEthereumTransaction {
@@ -430,6 +450,25 @@ pub(crate) struct AscEthereumTransaction {
     pub gas_price: AscPtr<AscBigInt>,
 }
 
+#[repr(C)]
+#[derive(AscType)]
+pub(crate) struct AscEthereumTransactionReceipt {
+    pub transaction_hash: AscPtr<AscH256>,
+    pub transaction_index: AscPtr<AscBigInt>,
+    pub cumulative_gas_used: AscPtr<AscBigInt>,
+    pub gas_used: AscPtr<AscBigInt>,
+    pub contract_address: AscPtr<AscH160>,
+    pub status: AscPtr<AscBigInt>,
+    pub root: AscPtr<AscH256>,
+
+    pub from: AscPtr<AscH160>,
+    pub to: AscPtr<AscH160>,
+    pub value: AscPtr<AscBigInt>,
+    pub gas_price: AscPtr<AscBigInt>,
+    pub gas: AscPtr<AscBigInt>,
+    pub input: AscPtr<AscBigInt>,
+}
+
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscEthereumTransaction_0_0_2 {