add parents_hash to BlockMetadata txn

1. change type of on-chain-resource BlockMetadataV2
2. handle NewBlockEventV2
3. generate new rpc api
4. update blockmetadata types check
5. upgrade TransactionStorage

chain/open-block/src/lib.rs

@@ -40,7 +40,6 @@ pub struct OpenedBlock {
     difficulty: U256,
     strategy: ConsensusStrategy,
     vm_metrics: Option<VMMetrics>,
-    tips_hash: Option<Vec<HashValue>>,
     blue_blocks: Option<Vec<Block>>,
 }
 
@@ -71,7 +70,7 @@ impl OpenedBlock {
         let chain_state =
             ChainStateDB::new(storage.into_super_arc(), Some(previous_header.state_root()));
         let chain_id = previous_header.chain_id();
-        let block_meta = BlockMetadata::new(
+        let block_meta = BlockMetadata::new_with_parents(
             previous_block_id,
             block_timestamp,
             author,
@@ -80,6 +79,7 @@ impl OpenedBlock {
             previous_header.number() + 1,
             chain_id,
             previous_header.gas_used(),
+            tips_hash.unwrap_or_default(),
         );
         let mut opened_block = Self {
             previous_block_info: block_info,
@@ -94,7 +94,6 @@ impl OpenedBlock {
             difficulty,
             strategy,
             vm_metrics,
-            tips_hash,
             blue_blocks,
         };
         opened_block.initialize()?;
@@ -299,7 +298,6 @@ impl OpenedBlock {
             self.difficulty,
             self.strategy,
             self.block_meta,
-            self.tips_hash,
         );
         Ok(block_template)
     }

chain/tests/test_block_chain.rs

@@ -31,7 +31,7 @@ fn test_chain_filter_events() {
     let event_type_tag = TypeTag::Struct(Box::new(StructTag {
         address: genesis_address(),
         module: Identifier::from_str("Block").unwrap(),
-        name: Identifier::from_str("NewBlockEvent").unwrap(),
+        name: Identifier::from_str("NewBlockEventV2").unwrap(),
         type_params: vec![],
     }));
 

etc/starcoin_types.yml

@@ -47,6 +47,10 @@ BlockMetadata:
     - chain_id:
         TYPENAME: ChainId
     - parent_gas_used: U64
+    - parents_hash:
+        OPTION:
+          SEQ:
+            TYPENAME: HashValue
 ChainId:
   STRUCT:
     - id: U8

rpc/api/generated_rpc_schema/chain.json

@@ -2179,6 +2179,16 @@
                   "type": "string",
                   "format": "HashValue"
                 },
+                "parents_hash": {
+                  "type": [
+                    "array",
+                    "null"
+                  ],
+                  "items": {
+                    "type": "string",
+                    "format": "HashValue"
+                  }
+                },
                 "timestamp": {
                   "type": "string"
                 },

rpc/api/src/types.rs

@@ -668,6 +668,7 @@ pub struct BlockMetadataView {
     pub number: StrView<BlockNumber>,
     pub chain_id: u8,
     pub parent_gas_used: StrView<u64>,
+    pub parents_hash: Option<Vec<HashValue>>,
 }
 
 impl From<BlockMetadata> for BlockMetadataView {
@@ -681,6 +682,7 @@ impl From<BlockMetadata> for BlockMetadataView {
             number,
             chain_id,
             parent_gas_used,
+            parents_hash,
         ) = origin.into_inner();
         BlockMetadataView {
             parent_hash,
@@ -691,6 +693,7 @@ impl From<BlockMetadata> for BlockMetadataView {
             number: number.into(),
             chain_id: chain_id.id(),
             parent_gas_used: parent_gas_used.into(),
+            parents_hash,
         }
     }
 }
@@ -707,8 +710,9 @@ impl Into<BlockMetadata> for BlockMetadataView {
             number,
             chain_id,
             parent_gas_used,
+            parents_hash,
         } = self;
-        BlockMetadata::new(
+        BlockMetadata::new_with_parents(
             parent_hash,
             timestamp.0,
             author,
@@ -717,6 +721,7 @@ impl Into<BlockMetadata> for BlockMetadataView {
             number.0,
             genesis_config::ChainId::new(chain_id),
             parent_gas_used.0,
+            parents_hash.unwrap_or_default(),
         )
     }
 }

storage/src/block/mod.rs

@@ -2,10 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 use crate::{
     define_storage,
-    storage::{
-        CodecKVStore, CodecWriteBatch, ColumnFamily, KeyCodec, SchemaStorage, StorageInstance,
-        ValueCodec,
-    },
+    storage::{CodecKVStore, StorageInstance, ValueCodec},
     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,
@@ -422,88 +419,4 @@ impl BlockStorage {
         self.failed_block_storage
             .put_raw(block_id, old_block.encode_value()?)
     }
-
-    fn upgrade_store<K, V1, V2, T1, T2>(
-        old_store: T1,
-        store: T2,
-        batch_size: usize,
-    ) -> Result<usize>
-    where
-        K: KeyCodec + Copy,
-        V1: ValueCodec + Into<V2>,
-        V2: ValueCodec,
-        T1: SchemaStorage + ColumnFamily<Key = K, Value = V1>,
-        T2: SchemaStorage + ColumnFamily<Key = K, Value = V2>,
-    {
-        let mut total_size: usize = 0;
-        let mut old_iter = old_store.iter()?;
-        old_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_iter {
-            let (id, old_block) = item?;
-            let block: V2 = 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_store
-                    .write_batch(to_delete.take().unwrap())
-                    .expect("should never fail");
-                store
-                    .write_batch(to_put.take().unwrap())
-                    .expect("should never fail");
-
-                to_delete = Some(CodecWriteBatch::new());
-                to_put = Some(CodecWriteBatch::new());
-            }
-        }
-        if item_count != 0 {
-            total_size = total_size.saturating_add(item_count);
-            old_store
-                .write_batch(to_delete.take().unwrap())
-                .expect("should never fail");
-            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_store(old_header_store, header_store, BATCH_SIZE)?;
-        info!("upgraded {total_size} block headers");
-
-        let old_block_store = OldBlockInnerStorage::new(instance.clone());
-        let block_store = BlockInnerStorage::new(instance.clone());
-        let total_blocks = Self::upgrade_store(old_block_store, block_store, BATCH_SIZE)?;
-        info!("upgraded {total_blocks} blocks");
-
-        let old_failed_block_store = OldFailedBlockStorage::new(instance.clone());
-        let failed_block_store = FailedBlockStorage::new(instance);
-        let total_failed_blocks =
-            Self::upgrade_store(old_failed_block_store, failed_block_store, BATCH_SIZE)?;
-        info!("upgraded {total_failed_blocks} failed_blocks");
-
-        Ok(())
-    }
 }

storage/src/lib.rs

@@ -73,6 +73,7 @@ pub const STATE_NODE_PREFIX_NAME: ColumnFamilyName = "state_node";
 pub const STATE_NODE_PREFIX_NAME_PREV: ColumnFamilyName = "state_node_prev";
 pub const CHAIN_INFO_PREFIX_NAME: ColumnFamilyName = "chain_info";
 pub const TRANSACTION_PREFIX_NAME: ColumnFamilyName = "transaction";
+pub const TRANSACTION_PREFIX_NAME_V2: ColumnFamilyName = "transaction_v2";
 pub const TRANSACTION_INFO_PREFIX_NAME: ColumnFamilyName = "transaction_info";
 pub const TRANSACTION_INFO_PREFIX_NAME_V2: ColumnFamilyName = "transaction_info_v2";
 pub const TRANSACTION_INFO_HASH_PREFIX_NAME: ColumnFamilyName = "transaction_info_hash";
@@ -168,6 +169,7 @@ static VEC_PREFIX_NAME_V4: Lazy<Vec<ColumnFamilyName>> = Lazy::new(|| {
         CONTRACT_EVENT_PREFIX_NAME,
         FAILED_BLOCK_PREFIX_NAME,
         FAILED_BLOCK_PREFIX_NAME_V2,
+        TRANSACTION_PREFIX_NAME_V2,
         TABLE_INFO_PREFIX_NAME,
     ]
 });

storage/src/transaction/legacy.rs

@@ -0,0 +1,22 @@
+use crate::storage::ValueCodec;
+use crate::{define_storage, TRANSACTION_PREFIX_NAME};
+use bcs_ext::BCSCodec;
+use starcoin_crypto::HashValue;
+use starcoin_vm_types::transaction::LegacyTransaction;
+
+define_storage!(
+    LegacyTransactionStorage,
+    HashValue,
+    LegacyTransaction,
+    TRANSACTION_PREFIX_NAME
+);
+
+impl ValueCodec for LegacyTransaction {
+    fn encode_value(&self) -> anyhow::Result<Vec<u8>> {
+        self.encode()
+    }
+
+    fn decode_value(data: &[u8]) -> anyhow::Result<Self> {
+        Self::decode(data)
+    }
+}

storage/src/transaction/mod.rs

@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::storage::{CodecKVStore, CodecWriteBatch, ValueCodec};
-use crate::TRANSACTION_PREFIX_NAME;
-use crate::{define_storage, TransactionStore};
+use crate::{define_storage, TransactionStore, TRANSACTION_PREFIX_NAME_V2};
 use anyhow::Result;
 use bcs_ext::BCSCodec;
+pub use legacy::LegacyTransactionStorage;
 use starcoin_crypto::HashValue;
 use starcoin_types::transaction::Transaction;
 
 define_storage!(
     TransactionStorage,
     HashValue,
     Transaction,
-    TRANSACTION_PREFIX_NAME
+    TRANSACTION_PREFIX_NAME_V2
 );
 
 impl ValueCodec for Transaction {
@@ -46,5 +46,6 @@ impl TransactionStore for TransactionStorage {
     }
 }
 
+mod legacy;
 #[cfg(test)]
 mod test;