From af622161d60c5dafdc17bcf7c84c58bef13b2dcc Mon Sep 17 00:00:00 2001 From: simonjiao Date: Wed, 6 Dec 2023 09:26:35 +0800 Subject: [PATCH] add storage upgrade from v3 to v4 --- flexidag/src/flexidag_service.rs | 9 +- genesis/src/lib.rs | 1 + storage/src/block/mod.rs | 254 +++++++++++++++++- storage/src/chain_info/mod.rs | 28 +- storage/src/lib.rs | 12 +- storage/src/upgrade.rs | 27 +- sync/src/block_connector/write_block_chain.rs | 6 +- types/src/block.rs | 65 ++++- types/src/startup_info.rs | 23 +- 9 files changed, 384 insertions(+), 41 deletions(-) diff --git a/flexidag/src/flexidag_service.rs b/flexidag/src/flexidag_service.rs index f61ffef739..eecd0a5dce 100644 --- a/flexidag/src/flexidag_service.rs +++ b/flexidag/src/flexidag_service.rs @@ -405,9 +405,7 @@ impl ServiceHandler for FlexidagService { k_total_difficulties: [msg.k_total_difficulty].into_iter().collect(), }); // broadcast the tip - ctx.broadcast(NewTips { - tips: new_tips, - }); + ctx.broadcast(NewTips { tips: new_tips }); self.storage = storage.clone(); Ok(()) } @@ -447,7 +445,8 @@ impl ServiceHandler for FlexidagService { None => { let storage = ctx.get_shared::>()?; let config = ctx.get_shared::>()?; - if header.number() == BlockDAG::dag_fork_height_with_net(config.net().id().clone()) { + if header.number() == BlockDAG::dag_fork_height_with_net(config.net().id().clone()) + { let (dag, dag_accumulator) = BlockDAG::try_init_with_storage(storage.clone(), config)?; if dag.is_none() { @@ -470,7 +469,7 @@ impl ServiceHandler for FlexidagService { storage .get_startup_info()? .map(|mut startup_info| { - startup_info.dag_main = Some(header.id()); + startup_info.update_dag_main(header.id()); storage.save_startup_info(startup_info) }) .expect("starup info should not be none") diff --git a/genesis/src/lib.rs b/genesis/src/lib.rs index 3b69665d28..d8dc27d79c 100644 --- a/genesis/src/lib.rs +++ b/genesis/src/lib.rs @@ -264,6 +264,7 @@ impl Genesis { self.block.clone(), net.id().clone(), )?; + // todo: check if it's dag genesis, and update StartupInfo.dag_main let startup_info = StartupInfo::new(genesis_chain.current_header().id()); storage.save_startup_info(startup_info)?; storage diff --git a/storage/src/block/mod.rs b/storage/src/block/mod.rs index eb3ef3bd69..196491a728 100644 --- a/storage/src/block/mod.rs +++ b/storage/src/block/mod.rs @@ -1,10 +1,11 @@ // Copyright (c) The Starcoin Core Contributors // SPDX-License-Identifier: Apache-2.0 use crate::define_storage; -use crate::storage::{CodecKVStore, StorageInstance, ValueCodec}; +use crate::storage::{CodecKVStore, CodecWriteBatch, StorageInstance, ValueCodec}; use crate::{ - BLOCK_BODY_PREFIX_NAME, BLOCK_HEADER_PREFIX_NAME, BLOCK_PREFIX_NAME, - BLOCK_TRANSACTIONS_PREFIX_NAME, BLOCK_TRANSACTION_INFOS_PREFIX_NAME, FAILED_BLOCK_PREFIX_NAME, + BLOCK_BODY_PREFIX_NAME, BLOCK_HEADER_PREFIX_NAME, BLOCK_HEADER_PREFIX_NAME_V2, + BLOCK_PREFIX_NAME, BLOCK_PREFIX_NAME_V2, BLOCK_TRANSACTIONS_PREFIX_NAME, + BLOCK_TRANSACTION_INFOS_PREFIX_NAME, FAILED_BLOCK_PREFIX_NAME, FAILED_BLOCK_PREFIX_NAME_V2, }; use anyhow::{bail, Result}; use bcs_ext::{BCSCodec, Sample}; @@ -12,7 +13,7 @@ use network_p2p_types::peer_id::PeerId; use serde::{Deserialize, Serialize}; use starcoin_crypto::HashValue; use starcoin_logger::prelude::*; -use starcoin_types::block::{Block, BlockBody, BlockHeader}; +use starcoin_types::block::{Block, BlockBody, BlockHeader, OldBlock, OldBlockHeader}; #[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)] pub struct OldFailedBlock { @@ -46,6 +47,26 @@ pub struct FailedBlock { version: String, } +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(rename(deserialize = "FailedBlock"))] +pub struct OldFailedBlockV2 { + block: OldBlock, + peer_id: Option, + failed: String, + version: String, +} + +impl From for FailedBlock { + fn from(value: OldFailedBlockV2) -> Self { + Self { + block: value.block.into(), + peer_id: value.peer_id, + failed: value.failed, + version: value.version, + } + } +} + #[allow(clippy::from_over_into)] impl Into<(Block, Option, String, String)> for FailedBlock { fn into(self) -> (Block, Option, String, String) { @@ -75,11 +96,18 @@ impl Sample for FailedBlock { } } -define_storage!(BlockInnerStorage, HashValue, Block, BLOCK_PREFIX_NAME); +define_storage!(BlockInnerStorage, HashValue, Block, BLOCK_PREFIX_NAME_V2); define_storage!( BlockHeaderStorage, HashValue, BlockHeader, + BLOCK_HEADER_PREFIX_NAME_V2 +); +define_storage!(OldBlockInnerStorage, HashValue, OldBlock, BLOCK_PREFIX_NAME); +define_storage!( + OldBlockHeaderStorage, + HashValue, + OldBlockHeader, BLOCK_HEADER_PREFIX_NAME ); @@ -102,10 +130,18 @@ define_storage!( Vec, BLOCK_TRANSACTION_INFOS_PREFIX_NAME ); + define_storage!( FailedBlockStorage, HashValue, FailedBlock, + FAILED_BLOCK_PREFIX_NAME_V2 +); + +define_storage!( + OldFailedBlockStorage, + HashValue, + OldFailedBlockV2, FAILED_BLOCK_PREFIX_NAME ); @@ -139,6 +175,26 @@ impl ValueCodec for BlockHeader { } } +impl ValueCodec for OldBlock { + fn encode_value(&self) -> Result> { + self.encode() + } + + fn decode_value(data: &[u8]) -> Result { + Self::decode(data) + } +} + +impl ValueCodec for OldBlockHeader { + fn encode_value(&self) -> Result> { + self.encode() + } + + fn decode_value(data: &[u8]) -> Result { + Self::decode(data) + } +} + impl ValueCodec for Vec { fn encode_value(&self) -> Result> { self.encode() @@ -178,6 +234,16 @@ impl ValueCodec for FailedBlock { } } +impl ValueCodec for OldFailedBlockV2 { + fn encode_value(&self) -> Result> { + self.encode() + } + + fn decode_value(data: &[u8]) -> Result { + Self::decode(data) + } +} + impl BlockStorage { pub fn new(instance: StorageInstance) -> Self { BlockStorage { @@ -220,12 +286,7 @@ impl BlockStorage { } pub fn get_blocks(&self, ids: Vec) -> Result>> { - Ok(self - .block_store - .multiple_get(ids)? - .into_iter() - .map(|cb| cb.map(|cb| cb.into())) - .collect()) + Ok(self.block_store.multiple_get(ids)?.into_iter().collect()) } pub fn get_body(&self, block_id: HashValue) -> Result> { @@ -331,4 +392,175 @@ impl BlockStorage { self.failed_block_storage .put_raw(block_id, old_block.encode_value()?) } + + fn upgrade_header_store( + old_header_store: OldBlockHeaderStorage, + header_store: BlockHeaderStorage, + batch_size: usize, + ) -> Result { + let mut total_size: usize = 0; + let mut old_header_iter = old_header_store.iter()?; + old_header_iter.seek_to_first(); + let mut to_deleted = Some(CodecWriteBatch::::new()); + let mut to_put = Some(CodecWriteBatch::::new()); + let mut item_count = 0usize; + for item in old_header_iter { + let (id, old_header) = item?; + let header: BlockHeader = old_header.into(); + to_deleted + .as_mut() + .unwrap() + .delete(id) + .expect("should never fail"); + to_put + .as_mut() + .unwrap() + .put(id, header) + .expect("should never fail"); + item_count += 1; + if item_count == batch_size { + total_size = total_size.saturating_add(item_count); + item_count = 0; + old_header_store.write_batch(to_deleted.take().unwrap())?; + header_store.write_batch(to_put.take().unwrap())?; + to_deleted = Some(CodecWriteBatch::::new()); + to_put = Some(CodecWriteBatch::::new()); + } + } + if item_count != 0 { + total_size = total_size.saturating_add(item_count); + old_header_store.write_batch(to_deleted.take().unwrap())?; + header_store.write_batch(to_put.take().unwrap())?; + } + + Ok(total_size) + } + + fn upgrade_block_store( + old_block_store: OldBlockInnerStorage, + block_store: BlockInnerStorage, + batch_size: usize, + ) -> Result { + let mut total_size: usize = 0; + let mut old_block_iter = old_block_store.iter()?; + old_block_iter.seek_to_first(); + + let mut to_delete = Some(CodecWriteBatch::new()); + let mut to_put = Some(CodecWriteBatch::new()); + let mut item_count = 0; + + for item in old_block_iter { + let (id, old_block) = item?; + let block: Block = old_block.into(); + to_delete + .as_mut() + .unwrap() + .delete(id) + .expect("should never fail"); + to_put + .as_mut() + .unwrap() + .put(id, block) + .expect("should never fail"); + + item_count += 1; + if item_count == batch_size { + total_size = total_size.saturating_add(item_count); + item_count = 0; + old_block_store + .write_batch(to_delete.take().unwrap()) + .expect("should never fail"); + block_store + .write_batch(to_put.take().unwrap()) + .expect("should never fail"); + } + } + if item_count != 0 { + total_size = total_size.saturating_add(item_count); + old_block_store + .write_batch(to_delete.take().unwrap()) + .expect("should never fail"); + block_store + .write_batch(to_put.take().unwrap()) + .expect("should never fail"); + } + + Ok(total_size) + } + + fn upgrade_failed_block_store( + old_failed_block_store: OldFailedBlockStorage, + failed_block_store: FailedBlockStorage, + batch_size: usize, + ) -> Result { + let mut total_size: usize = 0; + let mut old_failed_block_iter = old_failed_block_store.iter()?; + old_failed_block_iter.seek_to_first(); + + let mut to_delete = Some(CodecWriteBatch::new()); + let mut to_put = Some(CodecWriteBatch::new()); + let mut item_count = 0; + + for item in old_failed_block_iter { + let (id, old_block) = item?; + let block: FailedBlock = old_block.into(); + to_delete + .as_mut() + .unwrap() + .delete(id) + .expect("should never fail"); + to_put + .as_mut() + .unwrap() + .put(id, block) + .expect("should never fail"); + + item_count += 1; + if item_count == batch_size { + total_size = total_size.saturating_add(item_count); + item_count = 0; + old_failed_block_store + .write_batch(to_delete.take().unwrap()) + .expect("should never fail"); + failed_block_store + .write_batch(to_put.take().unwrap()) + .expect("should never fail"); + } + } + if item_count != 0 { + total_size = total_size.saturating_add(item_count); + old_failed_block_store + .write_batch(to_delete.take().unwrap()) + .expect("should never fail"); + failed_block_store + .write_batch(to_put.take().unwrap()) + .expect("should never fail"); + } + + Ok(total_size) + } + + pub fn upgrade_block_header(instance: StorageInstance) -> Result<()> { + const BATCH_SIZE: usize = 1000usize; + let old_header_store = OldBlockHeaderStorage::new(instance.clone()); + let header_store = BlockHeaderStorage::new(instance.clone()); + + let _total_size = Self::upgrade_header_store(old_header_store, header_store, BATCH_SIZE)?; + + let old_block_store = OldBlockInnerStorage::new(instance.clone()); + let block_store = BlockInnerStorage::new(instance.clone()); + + let _total_blocks = Self::upgrade_block_store(old_block_store, block_store, BATCH_SIZE)?; + + let old_failed_block_store = OldFailedBlockStorage::new(instance.clone()); + let failed_block_store = FailedBlockStorage::new(instance); + + let _total_failed_blocks = Self::upgrade_failed_block_store( + old_failed_block_store, + failed_block_store, + BATCH_SIZE, + )?; + + Ok(()) + } } diff --git a/storage/src/chain_info/mod.rs b/storage/src/chain_info/mod.rs index c83ce383ff..a9d4e24ad5 100644 --- a/storage/src/chain_info/mod.rs +++ b/storage/src/chain_info/mod.rs @@ -4,8 +4,10 @@ use crate::storage::{ColumnFamily, InnerStorage, KVStore}; use crate::{StorageVersion, CHAIN_INFO_PREFIX_NAME}; use anyhow::Result; +use bcs_ext::BCSCodec; use starcoin_crypto::HashValue; -use starcoin_types::startup_info::{BarnardHardFork, SnapshotRange, StartupInfo}; +use starcoin_logger::prelude::warn; +use starcoin_types::startup_info::{BarnardHardFork, OldStartupInfo, SnapshotRange, StartupInfo}; use std::convert::{TryFrom, TryInto}; #[derive(Clone)] @@ -24,6 +26,7 @@ pub type ChainInfoStorage = InnerStorage; impl ChainInfoStorage { const STARTUP_INFO_KEY: &'static str = "startup_info"; + const STARTUP_INFO_KEY_V2: &'static str = "startup_info_v2"; const GENESIS_KEY: &'static str = "genesis"; const STORAGE_VERSION_KEY: &'static str = "storage_version"; const SNAPSHOT_RANGE_KEY: &'static str = "snapshot_height"; @@ -46,7 +49,7 @@ impl ChainInfoStorage { } pub fn get_startup_info(&self) -> Result> { - self.get(Self::STARTUP_INFO_KEY.as_bytes()) + self.get(Self::STARTUP_INFO_KEY_V2.as_bytes()) .and_then(|bytes| match bytes { Some(bytes) => Ok(Some(bytes.try_into()?)), None => Ok(None), @@ -55,7 +58,7 @@ impl ChainInfoStorage { pub fn save_startup_info(&self, startup_info: StartupInfo) -> Result<()> { self.put_sync( - Self::STARTUP_INFO_KEY.as_bytes().to_vec(), + Self::STARTUP_INFO_KEY_V2.as_bytes().to_vec(), startup_info.try_into()?, ) } @@ -127,4 +130,23 @@ impl ChainInfoStorage { barnard_hard_fork.try_into()?, ) } + + // todo: + // 1. try to generic this function + pub fn upgrade_startup_info(&self) -> Result<()> { + if let Some(raw) = self.get(Self::STARTUP_INFO_KEY.as_bytes())? { + warn!( + "upgrading key {} to {}...", + Self::STARTUP_INFO_KEY, + Self::STARTUP_INFO_KEY_V2 + ); + let old = OldStartupInfo::decode(raw.as_slice())?; + let new = StartupInfo::new(old.main); + self.save_startup_info(new)?; + self.remove(Self::STARTUP_INFO_KEY.as_bytes().to_vec()) + } else { + warn!("key {} does not exist", Self::STARTUP_INFO_KEY); + Ok(()) + } + } } diff --git a/storage/src/lib.rs b/storage/src/lib.rs index 385939980d..935baa8bc1 100644 --- a/storage/src/lib.rs +++ b/storage/src/lib.rs @@ -23,10 +23,8 @@ use starcoin_accumulator::{ accumulator_info::AccumulatorInfo, node::AccumulatorStoreType, Accumulator, AccumulatorTreeStore, MerkleAccumulator, }; -use starcoin_config::ChainNetworkID; use starcoin_crypto::HashValue; use starcoin_state_store_api::{StateNode, StateNodeStore}; -use starcoin_types::block::BlockNumber; use starcoin_types::{ block::{Block, BlockBody, BlockHeader, BlockInfo}, contract_event::ContractEvent, @@ -74,6 +72,8 @@ pub const BLOCK_ACCUMULATOR_NODE_PREFIX_NAME: ColumnFamilyName = "acc_node_block pub const TRANSACTION_ACCUMULATOR_NODE_PREFIX_NAME: ColumnFamilyName = "acc_node_transaction"; pub const BLOCK_PREFIX_NAME: ColumnFamilyName = "block"; pub const BLOCK_HEADER_PREFIX_NAME: ColumnFamilyName = "block_header"; +pub const BLOCK_PREFIX_NAME_V2: ColumnFamilyName = "block_v2"; +pub const BLOCK_HEADER_PREFIX_NAME_V2: ColumnFamilyName = "block_header_v2"; pub const BLOCK_BODY_PREFIX_NAME: ColumnFamilyName = "block_body"; pub const BLOCK_INFO_PREFIX_NAME: ColumnFamilyName = "block_info"; pub const BLOCK_TRANSACTIONS_PREFIX_NAME: ColumnFamilyName = "block_txns"; @@ -87,6 +87,7 @@ pub const TRANSACTION_INFO_PREFIX_NAME_V2: ColumnFamilyName = "transaction_info_ pub const TRANSACTION_INFO_HASH_PREFIX_NAME: ColumnFamilyName = "transaction_info_hash"; pub const CONTRACT_EVENT_PREFIX_NAME: ColumnFamilyName = "contract_event"; pub const FAILED_BLOCK_PREFIX_NAME: ColumnFamilyName = "failed_block"; +pub const FAILED_BLOCK_PREFIX_NAME_V2: ColumnFamilyName = "failed_block_v2"; pub const TABLE_INFO_PREFIX_NAME: ColumnFamilyName = "table_info"; pub const SYNC_FLEXI_DAG_ACCUMULATOR_PREFIX_NAME: ColumnFamilyName = "sync_flexi_dag_accumulator"; pub const SYNC_FLEXI_DAG_SNAPSHOT_PREFIX_NAME: ColumnFamilyName = "sync_flexi_dag_snapshot"; @@ -163,6 +164,8 @@ static VEC_PREFIX_NAME_V4: Lazy> = Lazy::new(|| { TRANSACTION_ACCUMULATOR_NODE_PREFIX_NAME, BLOCK_PREFIX_NAME, BLOCK_HEADER_PREFIX_NAME, + BLOCK_PREFIX_NAME_V2, + BLOCK_HEADER_PREFIX_NAME_V2, BLOCK_BODY_PREFIX_NAME, // unused column BLOCK_INFO_PREFIX_NAME, BLOCK_TRANSACTIONS_PREFIX_NAME, @@ -175,6 +178,7 @@ static VEC_PREFIX_NAME_V4: Lazy> = Lazy::new(|| { TRANSACTION_INFO_HASH_PREFIX_NAME, CONTRACT_EVENT_PREFIX_NAME, FAILED_BLOCK_PREFIX_NAME, + FAILED_BLOCK_PREFIX_NAME_V2, SYNC_FLEXI_DAG_ACCUMULATOR_PREFIX_NAME, SYNC_FLEXI_DAG_SNAPSHOT_PREFIX_NAME, DAG_TIPS_PREFIX_NAME, @@ -721,8 +725,8 @@ impl SyncFlexiDagStore for Storage { k_total_difficulties: BTreeSet, ) -> Result<()> { let snapshot = SyncFlexiDagSnapshot { - child_hashes: new_tips.clone(), - accumulator_info: accumulator_info.clone(), + child_hashes: new_tips, + accumulator_info, head_block_id, k_total_difficulties, }; diff --git a/storage/src/upgrade.rs b/storage/src/upgrade.rs index e73b5d2f0e..9cb68e39e6 100644 --- a/storage/src/upgrade.rs +++ b/storage/src/upgrade.rs @@ -15,7 +15,7 @@ use anyhow::{bail, ensure, format_err, Result}; use once_cell::sync::Lazy; use starcoin_crypto::HashValue; use starcoin_logger::prelude::{debug, info, warn}; -use starcoin_types::block::{BlockHeader, BlockNumber}; +use starcoin_types::block::BlockNumber; use starcoin_types::startup_info::{BarnardHardFork, StartupInfo}; use starcoin_types::transaction::Transaction; use std::cmp::Ordering; @@ -163,8 +163,12 @@ impl DBUpgrade { Ok(()) } - fn db_upgrade_v3_v4(_instance: &mut StorageInstance) -> Result<()> { - // https://github.com/facebook/rocksdb/issues/1295 + fn db_upgrade_v3_v4(instance: &mut StorageInstance) -> Result<()> { + let chain_info_storage = ChainInfoStorage::new(instance.clone()); + chain_info_storage.upgrade_startup_info()?; + + BlockStorage::upgrade_block_header(instance.clone())?; + Ok(()) } @@ -190,10 +194,16 @@ impl DBUpgrade { (StorageVersion::V2, StorageVersion::V3) => { Self::db_upgrade_v2_v3(instance)?; } - (StorageVersion::V3, StorageVersion::V4) - | (StorageVersion::V1, StorageVersion::V4) - | (StorageVersion::V2, StorageVersion::V4) => { - // just for testing. todo + (StorageVersion::V1, StorageVersion::V4) => { + Self::db_upgrade_v1_v2(instance)?; + Self::db_upgrade_v2_v3(instance)?; + Self::db_upgrade_v3_v4(instance)?; + } + (StorageVersion::V2, StorageVersion::V4) => { + Self::db_upgrade_v2_v3(instance)?; + Self::db_upgrade_v3_v4(instance)?; + } + (StorageVersion::V3, StorageVersion::V4) => { Self::db_upgrade_v3_v4(instance)?; } _ => bail!( @@ -225,8 +235,7 @@ impl DBUpgrade { let mut iter = block_storage.header_store.iter()?; iter.seek_to_first(); for item in iter { - let (id, compat_block_header) = item?; - let block_header: BlockHeader = compat_block_header.into(); + let (id, block_header) = item?; if block_header.number() >= BARNARD_HARD_FORK_HEIGHT { block_info_storage.remove(id)?; processed_count += 1; diff --git a/sync/src/block_connector/write_block_chain.rs b/sync/src/block_connector/write_block_chain.rs index bcfd44f1da..0706e40a42 100644 --- a/sync/src/block_connector/write_block_chain.rs +++ b/sync/src/block_connector/write_block_chain.rs @@ -261,6 +261,7 @@ where let main_total_difficulty = self.main.get_total_difficulty()?; let branch_total_difficulty = new_branch.get_total_difficulty()?; if branch_total_difficulty > main_total_difficulty { + // todo: handle StartupInfo.dag_main self.update_startup_info(new_branch.head_block().header())?; ctx.broadcast(NewHeadBlock { executed_block: Arc::new(new_branch.head_block()), @@ -324,6 +325,7 @@ where enacted_blocks.last().unwrap().header, executed_block.block().header ); + // todo: handle StartupInfo.dag_main self.update_startup_info(executed_block.block().header())?; if retracted_count > 0 { if let Some(metrics) = self.metrics.as_ref() { @@ -427,7 +429,9 @@ where fn update_startup_info(&mut self, main_head: &BlockHeader) -> Result<()> { self.startup_info.update_main(main_head.id()); - self.storage.save_startup_info(self.startup_info.clone()) + self.storage.save_startup_info(self.startup_info.clone()); + + todo!("how to handle dag_main"); } fn commit_2_txpool(&self, enacted: Vec, retracted: Vec) { diff --git a/types/src/block.rs b/types/src/block.rs index 5ef975ba9e..736c1b32c9 100644 --- a/types/src/block.rs +++ b/types/src/block.rs @@ -7,7 +7,6 @@ use crate::genesis_config::{ChainId, ConsensusStrategy}; use crate::language_storage::CORE_CODE_ADDRESS; use crate::transaction::SignedUserTransaction; use crate::U256; -use anyhow::format_err; use bcs_ext::Sample; use schemars::{self, JsonSchema}; use serde::de::Error; @@ -169,7 +168,8 @@ pub struct BlockHeader { } // For single chain before FlexiDag upgrade -#[derive(Serialize, Deserialize, CryptoHasher, CryptoHash)] +#[derive(Clone, Debug, Serialize, Deserialize, CryptoHasher, CryptoHash)] +#[serde(rename = "BlockHeader")] pub struct OldBlockHeader { #[serde(skip)] #[allow(dead_code)] @@ -227,6 +227,29 @@ impl From for OldBlockHeader { } } +impl From for BlockHeader { + fn from(v: OldBlockHeader) -> Self { + Self { + id: v.id, + parent_hash: v.parent_hash, + timestamp: v.timestamp, + number: v.number, + author: v.author, + author_auth_key: v.author_auth_key, + txn_accumulator_root: v.txn_accumulator_root, + block_accumulator_root: v.block_accumulator_root, + state_root: v.state_root, + gas_used: v.gas_used, + difficulty: v.difficulty, + body_hash: v.body_hash, + chain_id: v.chain_id, + nonce: v.nonce, + extra: v.extra, + parents_hash: None, + } + } +} + impl BlockHeader { pub fn new( parent_hash: HashValue, @@ -699,6 +722,26 @@ pub struct BlockBody { pub uncles: Option>, } +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct OldBlockBody { + pub transactions: Vec, + pub uncles: Option>, +} + +impl From for BlockBody { + fn from(value: OldBlockBody) -> Self { + let OldBlockBody { + transactions, + uncles, + } = value; + + Self { + transactions, + uncles: uncles.map(|u| u.into_iter().map(|h| h.into()).collect::>()), + } + } +} + impl BlockBody { pub fn new(transactions: Vec, uncles: Option>) -> Self { Self { @@ -758,6 +801,22 @@ pub struct Block { pub body: BlockBody, } +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(rename(deserialize = "Block"))] +pub struct OldBlock { + pub header: OldBlockHeader, + pub body: OldBlockBody, +} + +impl From for Block { + fn from(value: OldBlock) -> Self { + Self { + header: value.header.into(), + body: value.body.into(), + } + } +} + impl Block { pub fn new(header: BlockHeader, body: B) -> Self where @@ -779,7 +838,7 @@ impl Block { // .map(|dag| dag.0.id()) // .ok_or_else(|| format_err!("missing parent and tips for dag block")) // } else { - Ok(self.header().parent_hash()) + Ok(self.header().parent_hash()) // } } diff --git a/types/src/startup_info.rs b/types/src/startup_info.rs index 156edf1f82..bbb2c09846 100644 --- a/types/src/startup_info.rs +++ b/types/src/startup_info.rs @@ -137,8 +137,12 @@ pub struct ChainStatus { } impl ChainStatus { - pub fn new(head: BlockHeader, info: BlockInfo,tips_hash: Option>) -> Self { - Self { head, info, tips_hash } + pub fn new(head: BlockHeader, info: BlockInfo, tips_hash: Option>) -> Self { + Self { + head, + info, + tips_hash, + } } pub fn random() -> Self { @@ -196,7 +200,7 @@ impl Sample for ChainStatus { Self { head: BlockHeader::sample(), info: BlockInfo::sample(), - tips_hash: None + tips_hash: None, } } } @@ -241,10 +245,16 @@ pub struct StartupInfo { pub dag_main: Option, } +#[derive(Serialize, Deserialize)] +pub struct OldStartupInfo { + pub main: HashValue, +} + impl fmt::Display for StartupInfo { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "StartupInfo {{")?; write!(f, "main: {:?},", self.main)?; + write!(f, "dag_main: {:?}", self.dag_main)?; write!(f, "}}")?; Ok(()) } @@ -258,8 +268,11 @@ impl StartupInfo { } } - pub fn new_with_dag(main: HashValue, dag_main: Option) -> Self { - Self { main, dag_main } + pub fn new_with_dag(main: HashValue, dag_main: HashValue) -> Self { + Self { + main, + dag_main: Some(dag_main), + } } pub fn update_main(&mut self, new_head: HashValue) {