add StcContractEvent

Author: simonjiao

chain/api/src/message.rs

@@ -5,10 +5,11 @@ use crate::TransactionInfoWithProof;
 use anyhow::Result;
 use starcoin_crypto::HashValue;
 use starcoin_service_registry::ServiceRequest;
+use starcoin_types::contract_event::StcContractEventInfo;
 use starcoin_types::transaction::RichTransactionInfo;
 use starcoin_types::{
-    block::{Block, BlockHeader, BlockInfo, BlockNumber},
-    contract_event::ContractEventInfo,
+    block::{Block, BlockHeader, BlockInfo, BlockNumber}
+    ,
     filter::Filter,
     startup_info::{ChainStatus, StartupInfo},
     transaction::Transaction,
@@ -83,8 +84,8 @@ pub enum ChainResponse {
     BlockHeaderVec(Vec<Option<BlockHeader>>),
     TransactionInfos(Vec<RichTransactionInfo>),
     TransactionInfo(Option<RichTransactionInfo>),
-    Events(Vec<ContractEventInfo>),
-    MainEvents(Vec<ContractEventInfo>),
+    Events(Vec<StcContractEventInfo>),
+    MainEvents(Vec<StcContractEventInfo>),
     HashVec(Vec<HashValue>),
     TransactionProof(Box<Option<TransactionInfoWithProof>>),
     BlockInfoVec(Box<Vec<Option<BlockInfo>>>),

chain/api/src/service.rs

@@ -6,7 +6,7 @@ use crate::TransactionInfoWithProof;
 use anyhow::{bail, Result};
 use starcoin_crypto::HashValue;
 use starcoin_service_registry::{ActorService, ServiceHandler, ServiceRef};
-use starcoin_types::contract_event::{ContractEvent, ContractEventInfo};
+use starcoin_types::contract_event::{ContractEvent, StcContractEventInfo};
 use starcoin_types::filter::Filter;
 use starcoin_types::startup_info::ChainStatus;
 use starcoin_types::transaction::{RichTransactionInfo, Transaction};
@@ -48,7 +48,7 @@ pub trait ReadableChainService {
         reverse: bool,
         count: u64,
     ) -> Result<Vec<Block>>;
-    fn get_main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>>;
+    fn get_main_events(&self, filter: Filter) -> Result<Vec<StcContractEventInfo>>;
     fn get_block_ids(
         &self,
         start_number: BlockNumber,
@@ -101,7 +101,10 @@ pub trait ChainAsyncService:
         block_hash: HashValue,
         idx: u64,
     ) -> Result<Option<RichTransactionInfo>>;
-    async fn get_events_by_txn_hash(&self, txn_hash: HashValue) -> Result<Vec<ContractEventInfo>>;
+    async fn get_events_by_txn_hash(
+        &self,
+        txn_hash: HashValue,
+    ) -> Result<Vec<StcContractEventInfo>>;
     /// for main
     async fn main_head_header(&self) -> Result<BlockHeader>;
     async fn main_head_block(&self) -> Result<Block>;
@@ -116,7 +119,7 @@ pub trait ChainAsyncService:
         -> Result<Option<BlockHeader>>;
     async fn main_startup_info(&self) -> Result<StartupInfo>;
     async fn main_status(&self) -> Result<ChainStatus>;
-    async fn main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>>;
+    async fn main_events(&self, filter: Filter) -> Result<Vec<StcContractEventInfo>>;
     async fn get_block_ids(
         &self,
         start_number: BlockNumber,
@@ -271,7 +274,10 @@ where
             bail!("get txn info by block and idx error.")
         }
     }
-    async fn get_events_by_txn_hash(&self, txn_hash: HashValue) -> Result<Vec<ContractEventInfo>> {
+    async fn get_events_by_txn_hash(
+        &self,
+        txn_hash: HashValue,
+    ) -> Result<Vec<StcContractEventInfo>> {
         let response = self
             .send(ChainRequest::GetEventsByTxnHash { txn_hash })
             .await??;
@@ -357,7 +363,7 @@ where
         }
     }
 
-    async fn main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>> {
+    async fn main_events(&self, filter: Filter) -> Result<Vec<StcContractEventInfo>> {
         let response = self.send(ChainRequest::MainEvents(filter)).await??;
         if let ChainResponse::MainEvents(evts) = response {
             Ok(evts)

chain/service/src/chain_service.rs

@@ -15,7 +15,7 @@ use starcoin_service_registry::{
 };
 use starcoin_storage::{BlockStore, Storage, Store};
 use starcoin_types::block::ExecutedBlock;
-use starcoin_types::contract_event::ContractEventInfo;
+use starcoin_types::contract_event::StcContractEventInfo;
 use starcoin_types::filter::Filter;
 use starcoin_types::system_events::NewHeadBlock;
 use starcoin_types::transaction::RichTransactionInfo;
@@ -186,14 +186,14 @@ impl ServiceHandler<Self, ChainRequest> for ChainReaderService {
                     events
                         .into_iter()
                         .enumerate()
-                        .map(|(idx, evt)| ContractEventInfo {
+                        .map(|(idx, evt)| StcContractEventInfo {
                             block_hash: txn_info.block_id,
                             block_number: txn_info.block_number,
                             transaction_hash: txn_hash,
                             transaction_index: txn_info.transaction_index,
                             transaction_global_index: txn_info.transaction_global_index,
                             event_index: idx as u32,
-                            event: evt,
+                            event: evt.into(),
                         })
                         .collect()
                 };
@@ -389,7 +389,7 @@ impl ReadableChainService for ChainReaderServiceInner {
         self.main.get_blocks_by_number(number, reverse, count)
     }
 
-    fn get_main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>> {
+    fn get_main_events(&self, filter: Filter) -> Result<Vec<StcContractEventInfo>> {
         self.main.filter_events(filter)
     }
 

chain/src/chain.rs

@@ -25,7 +25,7 @@ use starcoin_state_api::{AccountStateReader, ChainStateReader, ChainStateWriter}
 use starcoin_statedb::ChainStateDB;
 use starcoin_storage::Store;
 use starcoin_time_service::TimeService;
-use starcoin_types::contract_event::ContractEventInfo;
+use starcoin_types::contract_event::StcContractEventInfo;
 use starcoin_types::filter::Filter;
 use starcoin_types::multi_state::MultiState;
 use starcoin_types::multi_transaction::MultiSignedUserTransaction;
@@ -1370,7 +1370,7 @@ impl ChainReader for BlockChain {
 }
 
 impl BlockChain {
-    pub fn filter_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>> {
+    pub fn filter_events(&self, filter: Filter) -> Result<Vec<StcContractEventInfo>> {
         let (storage, _storage2) = &self.storage;
         let reverse = filter.reverse;
         let chain_header = self.current_header();
@@ -1427,14 +1427,14 @@ impl BlockChain {
                 })?;
 
                 let filtered_event_with_info =
-                    filtered_events.map(|(idx, evt)| ContractEventInfo {
+                    filtered_events.map(|(idx, evt)| StcContractEventInfo {
                         block_hash: block_id,
                         block_number: block.header().number(),
                         transaction_hash: txn_info.transaction_hash(),
                         transaction_index: txn_info.transaction_index,
                         transaction_global_index: txn_info.transaction_global_index,
                         event_index: idx as u32,
-                        event: evt,
+                        event: evt.into(),
                     });
                 if reverse {
                     event_with_infos.extend(filtered_event_with_info.rev())

types/src/contract_event.rs

@@ -0,0 +1,57 @@
+// Copyright (c) The Starcoin Core Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::event_info::{ContractEventInfo, StcContractEventInfo};
+pub use starcoin_vm_types::contract_event::*;
+
+use crate::event::StcEventKey;
+use crate::language_storage::StcTypeTag;
+use starcoin_vm2_vm_types::contract_event::ContractEvent as ContractEvent2;
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub enum StcContractEvent {
+    V1(ContractEvent),
+    V2(ContractEvent2),
+}
+
+impl From<ContractEvent> for StcContractEvent {
+    fn from(event: ContractEvent) -> Self {
+        Self::V1(event)
+    }
+}
+
+impl From<ContractEvent2> for StcContractEvent {
+    fn from(event: ContractEvent2) -> Self {
+        Self::V2(event)
+    }
+}
+
+impl StcContractEvent {
+    pub fn key(&self) -> StcEventKey {
+        match self {
+            Self::V1(event) => StcEventKey::V1(*event.key()),
+            Self::V2(event) => StcEventKey::V2(event.event_key()),
+        }
+    }
+
+    pub fn sequence_number(&self) -> u64 {
+        match self {
+            Self::V1(event) => event.sequence_number(),
+            Self::V2(event) => event.sequence_number(),
+        }
+    }
+
+    pub fn event_data(&self) -> &[u8] {
+        match self {
+            Self::V1(event) => event.event_data(),
+            Self::V2(event) => event.event_data(),
+        }
+    }
+
+    pub fn type_tag(&self) -> StcTypeTag {
+        match self {
+            Self::V1(event) => StcTypeTag::V1(event.type_tag().clone()),
+            Self::V2(event) => StcTypeTag::V2(event.type_tag().clone()),
+        }
+    }
+}

types/src/event_info.rs

@@ -1,5 +1,5 @@
 use crate::block::BlockNumber;
-use crate::contract_event::ContractEvent;
+use crate::contract_event::{ContractEvent, StcContractEvent};
 use starcoin_crypto::HashValue;
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
@@ -15,3 +15,17 @@ pub struct ContractEventInfo {
     pub event_index: u32,
     pub event: ContractEvent,
 }
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct StcContractEventInfo {
+    pub block_hash: HashValue,
+    pub block_number: BlockNumber,
+    pub transaction_hash: HashValue,
+    /// txn index in block
+    pub transaction_index: u32,
+    /// txn global index in chain
+    pub transaction_global_index: u64,
+    /// event index in the transaction events.
+    pub event_index: u32,
+    pub event: StcContractEvent,
+}

types/src/lib.rs

@@ -31,10 +31,7 @@ pub mod block_metadata {
     pub use starcoin_vm_types::block_metadata::BlockMetadata;
 }
 
-pub mod contract_event {
-    pub use crate::event_info::ContractEventInfo;
-    pub use starcoin_vm_types::contract_event::*;
-}
+pub mod contract_event;
 
 // pub mod time {
 //     pub use starcoin_vm_types::time::*;
@@ -44,6 +41,15 @@ pub mod error;
 
 pub mod event {
     pub use starcoin_vm_types::event::*;
+
+    use serde::{Deserialize, Serialize};
+    use starcoin_vm2_vm_types::event::EventKey as EventKey2;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    pub enum StcEventKey {
+        V1(EventKey),
+        V2(EventKey2),
+    }
 }
 
 pub mod filter;
@@ -68,9 +74,30 @@ pub mod vm_error {
 }
 
 pub mod language_storage {
+    use serde::{Deserialize, Serialize};
     pub use starcoin_vm_types::language_storage::{
         ModuleId, ResourceKey, StructTag, TypeTag, CODE_TAG, CORE_CODE_ADDRESS, RESOURCE_TAG,
     };
+
+    use starcoin_vm2_vm_types::language_storage::TypeTag as TypeTag2;
+
+    #[derive(Serialize, Deserialize, Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
+    pub enum StcTypeTag {
+        V1(TypeTag),
+        V2(TypeTag2),
+    }
+
+    impl From<TypeTag> for StcTypeTag {
+        fn from(tag: TypeTag) -> Self {
+            StcTypeTag::V1(tag)
+        }
+    }
+
+    impl From<TypeTag2> for StcTypeTag {
+        fn from(tag: TypeTag2) -> Self {
+            StcTypeTag::V2(tag)
+        }
+    }
 }
 
 pub mod identifier {