Store old blocks and txs after regenesis (#1811)

Work towards #1790

This PR adds `OldFuelBlocks`, `OldFuelBlockConsensus` and
`OldTransactions` tables to the off-chain database. If the requested
block is lower than genesis block height, we go to
`off_chain::OldFuelBlocks` , otherwise to `on_chain::FuelBlocks`. For
transactions, we try `on_chain::Transactions` and fallback to
`off_chain::OldTransactions`.

Also exposes `fuel_core_bin` as a library to help with e2e testing.

## Checklist
- [x] Breaking changes are clearly marked as such in the PR description
and changelog (no breaking changes)
- [x] New behavior is reflected in tests
- [x] [The specification](https://github.com/FuelLabs/fuel-specs/)
matches the implemented behavior (link update PR if changes are needed)

### Before requesting review
- [x] I have reviewed the code myself

### Before merge
- [x] Retarget to master branch

---------

Co-authored-by: Green Baneling <[email protected]>

Author: Dentosal

CHANGELOG.md

@@ -19,6 +19,7 @@ Description of the upcoming release here.
 - [#1821](https://github.com/FuelLabs/fuel-core/pull/1821): Propagate shutdown signal to (re)genesis. Also add progress bar for (re)genesis.
 - [#1813](https://github.com/FuelLabs/fuel-core/pull/1813): Added back support for `/health` endpoint.
 - [#1799](https://github.com/FuelLabs/fuel-core/pull/1799): Snapshot creation is now concurrent.
+- [#1811](https://github.com/FuelLabs/fuel-core/pull/1811): Regenesis now preserves old blocks and transactions for GraphQL API.
 
 ### Changed
 

Cargo.lock

@@ -141,8 +141,11 @@ pub async fn run_cli() -> anyhow::Result<()> {
 pub fn local_testnet_chain_config() -> ChainConfig {
     const TESTNET_CHAIN_CONFIG: &[u8] =
         include_bytes!("../chainspec/testnet/chain_config.json");
+    const TESTNET_CHAIN_CONFIG_STATE_BYTECODE: &[u8] =
+        include_bytes!("../chainspec/testnet/state_transition_bytecode.wasm");
 
-    let config: ChainConfig = serde_json::from_slice(TESTNET_CHAIN_CONFIG).unwrap();
+    let mut config: ChainConfig = serde_json::from_slice(TESTNET_CHAIN_CONFIG).unwrap();
+    config.state_transition_bytecode = TESTNET_CHAIN_CONFIG_STATE_BYTECODE.to_vec();
     config
 }
 

bin/fuel-core/chainspec/dev-testnet/state_transition_bytecode.wasm

@@ -371,7 +371,7 @@ impl Command {
     }
 }
 
-pub async fn exec(command: Command) -> anyhow::Result<()> {
+pub fn get_service(command: Command) -> anyhow::Result<FuelService> {
     #[cfg(any(feature = "rocks-db", feature = "rocksdb-production"))]
     if command.db_prune && command.database_path.exists() {
         fuel_core::combined_database::CombinedDatabase::prune(&command.database_path)?;
@@ -389,7 +389,11 @@ pub async fn exec(command: Command) -> anyhow::Result<()> {
     // initialize the server
     let combined_database = CombinedDatabase::from_config(&config.combined_db_config)?;
 
-    let service = FuelService::new(combined_database, config)?;
+    FuelService::new(combined_database, config)
+}
+
+pub async fn exec(command: Command) -> anyhow::Result<()> {
+    let service = get_service(command)?;
 
     // Genesis could take a long time depending on the snapshot size. Start needs to be
     // interruptible by the shutdown_signal

bin/fuel-core/chainspec/testnet/state_transition_bytecode.wasm

@@ -0,0 +1,9 @@
+#![deny(clippy::arithmetic_side_effects)]
+#![deny(clippy::cast_possible_truncation)]
+#![deny(unused_crate_dependencies)]
+#![deny(warnings)]
+
+pub mod cli;
+pub use fuel_core::service::FuelService;
+
+use tikv_jemallocator as _; // Used only by the binary

bin/fuel-core/src/cli.rs

@@ -1,15 +1,8 @@
-#![deny(clippy::arithmetic_side_effects)]
-#![deny(clippy::cast_possible_truncation)]
-#![deny(unused_crate_dependencies)]
-#![deny(warnings)]
-
 // Use Jemalloc for main binary
 #[global_allocator]
 static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
-use fuel_core::service::FuelService;
-
-mod cli;
+use fuel_core_bin::cli;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

bin/fuel-core/src/cli/run.rs

@@ -16,7 +16,15 @@ use fuel_core_storage::{
     ContractsStateKey,
 };
 use fuel_core_types::{
-    blockchain::primitives::DaBlockHeight,
+    blockchain::{
+        block::CompressedBlock,
+        consensus::{
+            poa::PoAConsensus,
+            Consensus,
+        },
+        header::PartialBlockHeader,
+        primitives::DaBlockHeight,
+    },
     entities::{
         coins::coin::{
             CompressedCoin,
@@ -29,18 +37,29 @@ use fuel_core_types::{
         relayer::message::MessageV1,
         Message,
     },
+    fuel_asm::{
+        op,
+        RegId,
+    },
     fuel_tx::{
         ContractId,
+        Transaction,
+        TransactionBuilder,
+        UniqueIdentifier,
         UtxoId,
     },
     fuel_types::{
         Address,
         AssetId,
         BlockHeight,
         Bytes32,
+        ChainId,
         Nonce,
     },
-    fuel_vm::Salt,
+    fuel_vm::{
+        Salt,
+        Signature,
+    },
 };
 
 use crate::TableEntry;
@@ -171,3 +190,39 @@ impl Randomize for ContractsStateKey {
         Self::new(&contract_id, &state_key)
     }
 }
+
+impl Randomize for CompressedBlock {
+    fn randomize(mut rng: impl rand::Rng) -> Self {
+        let tx1: Transaction = Randomize::randomize(&mut rng);
+        let tx2: Transaction = Randomize::randomize(&mut rng);
+
+        let tx_ids = vec![tx1.id(&ChainId::default()), tx2.id(&ChainId::default())];
+
+        Self::test(
+            PartialBlockHeader::default().generate(&[tx1, tx2], &[], rng.gen()),
+            tx_ids,
+        )
+    }
+}
+
+impl Randomize for (BlockHeight, Consensus) {
+    fn randomize(mut rng: impl rand::Rng) -> Self {
+        (
+            rng.gen::<u32>().into(),
+            Consensus::PoA(PoAConsensus::new(Signature::from_bytes([rng.gen(); 64]))),
+        )
+    }
+}
+
+impl Randomize for Transaction {
+    fn randomize(mut rng: impl rand::Rng) -> Self {
+        let program: Vec<u8> = [op::ret(RegId::ONE)].into_iter().collect();
+        match rng.gen_range(0..2) {
+            0 => TransactionBuilder::create(program.into(), rng.gen(), vec![rng.gen()])
+                .finalize_as_transaction(),
+            1 => TransactionBuilder::script(program, vec![rng.gen(), rng.gen()])
+                .finalize_as_transaction(),
+            _ => unreachable!(),
+        }
+    }
+}

bin/fuel-core/src/lib.rs

@@ -16,7 +16,9 @@ use fuel_core_storage::{
         ContractsLatestUtxo,
         ContractsRawCode,
         ContractsState,
+        FuelBlocks,
         Messages,
+        SealedBlockConsensus,
         Transactions,
     },
     ContractsAssetKey,
@@ -408,11 +410,29 @@ impl AsTable<Transactions> for StateConfig {
 }
 
 impl AddTable<Transactions> for StateConfigBuilder {
-    fn add(&mut self, _entries: Vec<TableEntry<Transactions>>) {
-        // Do not include these for now
+    fn add(&mut self, _entries: Vec<TableEntry<Transactions>>) {}
+}
+
+impl AsTable<FuelBlocks> for StateConfig {
+    fn as_table(&self) -> Vec<TableEntry<FuelBlocks>> {
+        Vec::new() // Do not include these for now
+    }
+}
+
+impl AddTable<FuelBlocks> for StateConfigBuilder {
+    fn add(&mut self, _entries: Vec<TableEntry<FuelBlocks>>) {}
+}
+
+impl AsTable<SealedBlockConsensus> for StateConfig {
+    fn as_table(&self) -> Vec<TableEntry<SealedBlockConsensus>> {
+        Vec::new() // Do not include these for now
     }
 }
 
+impl AddTable<SealedBlockConsensus> for StateConfigBuilder {
+    fn add(&mut self, _entries: Vec<TableEntry<SealedBlockConsensus>>) {}
+}
+
 impl StateConfig {
     pub fn sorted(mut self) -> Self {
         self.coins = self
@@ -677,6 +697,8 @@ mod tests {
         let mut rng = StdRng::seed_from_u64(0);
         let state_config = StateConfig::randomize(&mut rng);
 
+        let chain_config = ChainConfig::local_testnet();
+
         macro_rules! write_in_fragments {
                 ($($fragment_ty: ty,)*) => {
                 [
@@ -692,7 +714,6 @@ mod tests {
             }
             }
 
-        let chain_config = ChainConfig::local_testnet();
         let fragments = write_in_fragments!(
             Coins,
             Messages,

bin/fuel-core/src/main.rs

@@ -14,6 +14,7 @@ use crate::fuel_core_graphql_api::{
 use fuel_core_storage::{
     iter::{
         BoxedIter,
+        IntoBoxedIter,
         IterDirection,
     },
     transactional::AtomicView,
@@ -29,6 +30,7 @@ use fuel_core_txpool::types::{
 use fuel_core_types::{
     blockchain::{
         block::CompressedBlock,
+        consensus::Consensus,
         primitives::{
             BlockId,
             DaBlockHeight,
@@ -117,12 +119,56 @@ impl DatabaseBlocks for ReadView {
         height: Option<BlockHeight>,
         direction: IterDirection,
     ) -> BoxedIter<'_, StorageResult<CompressedBlock>> {
-        self.on_chain.blocks(height, direction)
+        // Chain together blocks from the off-chain db and the on-chain db
+        // The blocks in off-chain db, if any, are from time before regenesis
+
+        if let Some(height) = height {
+            match self.on_chain.latest_genesis_height() {
+                Ok(onchain_start_height) => {
+                    match (height >= onchain_start_height, direction) {
+                        (true, IterDirection::Forward) => {
+                            self.on_chain.blocks(Some(height), direction)
+                        }
+                        (true, IterDirection::Reverse) => self
+                            .on_chain
+                            .blocks(Some(height), direction)
+                            .chain(self.off_chain.old_blocks(None, direction))
+                            .into_boxed(),
+                        (false, IterDirection::Forward) => self
+                            .off_chain
+                            .old_blocks(Some(height), direction)
+                            .chain(self.on_chain.blocks(None, direction))
+                            .into_boxed(),
+                        (false, IterDirection::Reverse) => {
+                            self.off_chain.old_blocks(Some(height), direction)
+                        }
+                    }
+                }
+                Err(err) => core::iter::once(Err(err)).into_boxed(),
+            }
+        } else {
+            match direction {
+                IterDirection::Forward => self
+                    .off_chain
+                    .old_blocks(None, direction)
+                    .chain(self.on_chain.blocks(None, direction))
+                    .into_boxed(),
+                IterDirection::Reverse => self
+                    .on_chain
+                    .blocks(None, direction)
+                    .chain(self.off_chain.old_blocks(None, direction))
+                    .into_boxed(),
+            }
+        }
     }
 
     fn latest_height(&self) -> StorageResult<BlockHeight> {
         self.on_chain.latest_height()
     }
+
+    fn latest_genesis_height(&self) -> StorageResult<BlockHeight> {
+        self.on_chain.latest_genesis_height()
+    }
 }
 
 impl<M> StorageInspect<M> for ReadView
@@ -242,6 +288,25 @@ impl OffChainDatabase for ReadView {
         self.off_chain.contract_salt(contract_id)
     }
 
+    fn old_blocks(
+        &self,
+        height: Option<BlockHeight>,
+        direction: IterDirection,
+    ) -> BoxedIter<'_, StorageResult<CompressedBlock>> {
+        self.off_chain.old_blocks(height, direction)
+    }
+
+    fn old_block_consensus(&self, height: BlockHeight) -> StorageResult<Consensus> {
+        self.off_chain.old_block_consensus(height)
+    }
+
+    fn old_transaction(
+        &self,
+        id: &TxId,
+    ) -> StorageResult<Option<fuel_core_types::fuel_tx::Transaction>> {
+        self.off_chain.old_transaction(id)
+    }
+
     fn relayed_tx_status(
         &self,
         id: Bytes32,

crates/chain-config/src/config/randomize.rs

@@ -22,6 +22,7 @@ use fuel_core_txpool::service::TxStatusMessage;
 use fuel_core_types::{
     blockchain::{
         block::CompressedBlock,
+        consensus::Consensus,
         primitives::{
             BlockId,
             DaBlockHeight,
@@ -91,6 +92,16 @@ pub trait OffChainDatabase: Send + Sync {
 
     fn contract_salt(&self, contract_id: &ContractId) -> StorageResult<Salt>;
 
+    fn old_blocks(
+        &self,
+        height: Option<BlockHeight>,
+        direction: IterDirection,
+    ) -> BoxedIter<'_, StorageResult<CompressedBlock>>;
+
+    fn old_block_consensus(&self, height: BlockHeight) -> StorageResult<Consensus>;
+
+    fn old_transaction(&self, id: &TxId) -> StorageResult<Option<Transaction>>;
+
     fn relayed_tx_status(
         &self,
         id: Bytes32,
@@ -123,6 +134,9 @@ pub trait DatabaseBlocks:
     ) -> BoxedIter<'_, StorageResult<CompressedBlock>>;
 
     fn latest_height(&self) -> StorageResult<BlockHeight>;
+
+    /// First (i.e. lowest) height stored in this db.
+    fn latest_genesis_height(&self) -> StorageResult<BlockHeight>;
 }
 
 /// Trait that specifies all the getters required for messages.
@@ -230,7 +244,14 @@ pub mod worker {
             contracts::ContractsInfo,
             messages::OwnedMessageIds,
         },
-        graphql_api::storage::relayed_transactions::RelayedTransactionStatuses,
+        graphql_api::storage::{
+            old::{
+                OldFuelBlockConsensus,
+                OldFuelBlocks,
+                OldTransactions,
+            },
+            relayed_transactions::RelayedTransactionStatuses,
+        },
     };
     use fuel_core_services::stream::BoxStream;
     use fuel_core_storage::{
@@ -264,6 +285,9 @@ pub mod worker {
         + StorageMutate<OwnedCoins, Error = StorageError>
         + StorageMutate<FuelBlockIdsToHeights, Error = StorageError>
         + StorageMutate<ContractsInfo, Error = StorageError>
+        + StorageMutate<OldFuelBlocks, Error = StorageError>
+        + StorageMutate<OldFuelBlockConsensus, Error = StorageError>
+        + StorageMutate<OldTransactions, Error = StorageError>
         + StorageMutate<RelayedTransactionStatuses, Error = StorageError>
     {
         fn record_tx_id_owner(