ckb 2023 edition

chain/src/chain.rs

@@ -21,6 +21,7 @@ use ckb_types::{
             resolve_transaction, BlockCellProvider, HeaderChecker, OverlayCellProvider,
             ResolvedTransaction,
         },
+        hardfork::HardForks,
         service::{Request, DEFAULT_CHANNEL_SIZE, SIGNAL_CHANNEL_SIZE},
         BlockExt, BlockNumber, BlockView, Cycle, HeaderView,
     },
@@ -173,6 +174,35 @@ impl ForkChanges {
             blk.header().number()
         })
     }
+
+    pub fn during_hardfork(&self, hardfork_switch: &HardForks) -> bool {
+        let hardfork_during_detach =
+            self.check_if_hardfork_during_blocks(hardfork_switch, &self.detached_blocks);
+        let hardfork_during_attach =
+            self.check_if_hardfork_during_blocks(hardfork_switch, &self.attached_blocks);
+
+        hardfork_during_detach || hardfork_during_attach
+    }
+
+    fn check_if_hardfork_during_blocks(
+        &self,
+        hardfork: &HardForks,
+        blocks: &VecDeque<BlockView>,
+    ) -> bool {
+        if blocks.is_empty() {
+            false
+        } else {
+            // This method assumes that the input blocks are sorted and unique.
+            let rfc_0148 = hardfork.ckb2023.rfc_0148();
+            let epoch_first = blocks.front().unwrap().epoch().number();
+            let epoch_next = blocks
+                .back()
+                .unwrap()
+                .epoch()
+                .minimum_epoch_number_after_n_blocks(1);
+            epoch_first < rfc_0148 && rfc_0148 <= epoch_next
+        }
+    }
 }
 
 pub(crate) struct GlobalIndex {
@@ -729,9 +759,19 @@ impl ChainService {
         }
 
         let txs_verify_cache = self.shared.txs_verify_cache();
-        let consensus = self.shared.cloned_consensus();
+
+        let consensus = self.shared.consensus();
+        let hardfork_switch = consensus.hardfork_switch();
+        let during_hardfork = fork.during_hardfork(hardfork_switch);
         let async_handle = self.shared.tx_pool_controller().handle();
 
+        if during_hardfork {
+            async_handle.block_on(async {
+                txs_verify_cache.write().await.clear();
+            });
+        }
+
+        let consensus = self.shared.cloned_consensus();
         let start_block_header = fork.attached_blocks()[0].header();
         let mmr_size = leaf_index_to_mmr_size(start_block_header.number() - 1);
         trace!("light-client: new chain root MMR with size = {}", mmr_size);

chain/src/tests/load_code_with_snapshot.rs

@@ -8,8 +8,10 @@ use ckb_types::prelude::*;
 use ckb_types::{
     bytes::Bytes,
     core::{
-        capacity_bytes, hardfork::HardForkSwitch, BlockBuilder, Capacity, EpochNumberWithFraction,
-        ScriptHashType, TransactionBuilder, TransactionView,
+        capacity_bytes,
+        hardfork::{HardForks, CKB2021, CKB2023},
+        BlockBuilder, Capacity, EpochNumberWithFraction, ScriptHashType, TransactionBuilder,
+        TransactionView,
     },
     packed::{self, CellDep, CellInput, CellOutputBuilder, OutPoint, Script},
     utilities::DIFF_TWO,
@@ -235,11 +237,14 @@ fn _test_load_code_with_snapshot_after_hardfork(script_type: ScriptHashType) {
         .dao(dao)
         .build();
 
-    let hardfork_switch = HardForkSwitch::new_mirana()
-        .as_builder()
-        .rfc_0032(0)
-        .build()
-        .unwrap();
+    let hardfork_switch = HardForks {
+        ckb2021: CKB2021::new_mirana()
+            .as_builder()
+            .rfc_0032(0)
+            .build()
+            .unwrap(),
+        ckb2023: CKB2023::new_mirana().as_builder().build().unwrap(),
+    };
     let consensus = ConsensusBuilder::default()
         .cellbase_maturity(EpochNumberWithFraction::new(0, 0, 1))
         .genesis_block(genesis_block)

docs/hashes.toml

@@ -85,7 +85,7 @@ tx_hash = "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37"
 index = 1
 
 [ckb_staging]
-spec_hash = "0x1e501d0048dbfee37707432fb5ec4c5e2b0404d887ebc882564c8761ef54e68a"
+spec_hash = "0x7a0ed50e9723e6c41a5c8450225e9f0a639070bb81b87e395fd5f91eef6ce373"
 genesis = "0xbc081e6b2e31149c1dc39007f161ed0a0b63d5d30b3b771acc6a3b622133fcc0"
 cellbase = "0x7295631c414e50a8d9bb73d9845231ac212d10404045c96de7f149ec874ac6b7"
 
@@ -127,7 +127,7 @@ tx_hash = "0xd5780747735fd22c9ba7363bde8afe59061658caa836962867253b03cbda264e"
 index = 1
 
 [ckb_dev]
-spec_hash = "0x307bfa518f3dd6ffe6d82317c5ce7eb738db4623402edcc06b5adbee2e3a6b29"
+spec_hash = "0xdd75ca95ff59da78879506a46f509adf4e8d131f1826827be708408e60ebde37"
 genesis = "0x823b2ff5785b12da8b1363cac9a5cbe566d8b715a4311441b119c39a0367488c"
 cellbase = "0xa563884b3686078ec7e7677a5f86449b15cf2693f3c1241766c6996f206cc541"
 

network/src/network.rs

@@ -86,6 +86,8 @@ pub struct NetworkState {
     /// fields: ProtocolId, Protocol Name, Supported Versions
     pub(crate) protocols: RwLock<Vec<(ProtocolId, String, Vec<String>)>>,
     pub(crate) required_flags: Flags,
+
+    pub(crate) ckb2023: AtomicBool,
 }
 
 impl NetworkState {
@@ -137,9 +139,16 @@ impl NetworkState {
             active: AtomicBool::new(true),
             protocols: RwLock::new(Vec::new()),
             required_flags: Flags::SYNC | Flags::DISCOVERY | Flags::RELAY,
+            ckb2023: AtomicBool::new(false),
         })
     }
 
+    /// fork flag
+    pub fn ckb2023(self, init: bool) -> Self {
+        self.ckb2023.store(init, Ordering::SeqCst);
+        self
+    }
+
     /// use to discovery get nodes message to announce what kind of node information need from the other peer
     /// default with `Flags::SYNC | Flags::DISCOVERY | Flags::RELAY`
     pub fn required_flags(mut self, flags: Flags) -> Self {
@@ -1175,6 +1184,16 @@ pub struct NetworkController {
 }
 
 impl NetworkController {
+    /// Set ckb2023 start
+    pub fn init_ckb2023(&self) {
+        self.network_state.ckb2023.store(true, Ordering::SeqCst);
+    }
+
+    /// Get ckb2023 flag
+    pub fn load_ckb2023(&self) -> bool {
+        self.network_state.ckb2023.load(Ordering::SeqCst)
+    }
+
     /// Node listen address list
     pub fn public_urls(&self, max_urls: usize) -> Vec<(String, u8)> {
         self.network_state.public_urls(max_urls)

network/src/protocols/feeler.rs

@@ -6,7 +6,7 @@ use p2p::{
     context::{ProtocolContext, ProtocolContextMutRef},
     traits::ServiceProtocol,
 };
-use std::sync::Arc;
+use std::sync::{atomic::Ordering, Arc};
 
 /// Feeler
 /// Currently do nothing, CKBProtocol auto refresh peer_store after connected.
@@ -24,9 +24,15 @@ impl Feeler {
 impl ServiceProtocol for Feeler {
     async fn init(&mut self, _context: &mut ProtocolContext) {}
 
-    async fn connected(&mut self, context: ProtocolContextMutRef<'_>, _version: &str) {
+    async fn connected(&mut self, context: ProtocolContextMutRef<'_>, version: &str) {
         let session = context.session;
-        if context.session.ty.is_outbound() {
+        if self.network_state.ckb2023.load(Ordering::SeqCst) && version != "3" {
+            self.network_state
+                .peer_store
+                .lock()
+                .mut_addr_manager()
+                .remove(&session.address);
+        } else if context.session.ty.is_outbound() {
             let flags = self.network_state.with_peer_registry(|reg| {
                 if let Some(p) = reg.get_peer(session.id) {
                     p.identify_info

network/src/protocols/identify/mod.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{atomic::Ordering, Arc};
 use std::time::{Duration, Instant};
 
 use ckb_logger::{debug, error, trace, warn};
@@ -370,7 +370,18 @@ impl Callback for IdentifyCallback {
     }
 
     fn unregister(&self, context: &ProtocolContextMutRef) {
-        if context.session.ty.is_outbound() {
+        let protocol_version_match = self
+            .network_state
+            .with_peer_registry(|reg| {
+                reg.get_peer(context.session.id)
+                    .map(|p| p.protocol_version(context.proto_id))
+            })
+            .flatten()
+            .map(|version| version != "3")
+            .unwrap_or_default();
+
+        if self.network_state.ckb2023.load(Ordering::SeqCst) && protocol_version_match {
+        } else if context.session.ty.is_outbound() {
             // Due to the filtering strategy of the peer store, if the node is
             // disconnected after a long connection is maintained for more than seven days,
             // it is possible that the node will be accidentally evicted, so it is necessary
@@ -416,14 +427,40 @@ impl Callback for IdentifyCallback {
 
                 let required_flags = self.network_state.required_flags;
 
+                let protocol_version_match = self
+                    .network_state
+                    .with_peer_registry(|reg| {
+                        reg.get_peer(context.session.id)
+                            .map(|p| p.protocol_version(context.proto_id))
+                    })
+                    .flatten()
+                    .map(|version| version != "3")
+                    .unwrap_or_default();
+                let ckb2023 = self.network_state.ckb2023.load(Ordering::SeqCst);
+
+                let renew = if ckb2023 && protocol_version_match {
+                    if context.session.ty.is_outbound() {
+                        self.network_state
+                            .peer_store
+                            .lock()
+                            .mut_addr_manager()
+                            .remove(&context.session.address);
+                    }
+                    false
+                } else {
+                    true
+                };
+
                 if context.session.ty.is_outbound() {
                     // why don't set inbound here?
                     // because inbound address can't feeler during staying connected
                     // and if set it to peer store, it will be broadcast to the entire network,
                     // but this is an unverified address
-                    self.network_state.with_peer_store_mut(|peer_store| {
-                        peer_store.add_outbound_addr(context.session.address.clone(), flags);
-                    });
+                    if renew {
+                        self.network_state.with_peer_store_mut(|peer_store| {
+                            peer_store.add_outbound_addr(context.session.address.clone(), flags);
+                        });
+                    }
 
                     if self
                         .network_state
@@ -441,7 +478,12 @@ impl Callback for IdentifyCallback {
                             .open_protocols(
                                 context.session.id,
                                 TargetProtocol::Filter(Box::new(move |id| {
-                                    id != &SupportProtocols::Feeler.protocol_id()
+                                    if ckb2023 {
+                                        id != &SupportProtocols::Feeler.protocol_id()
+                                            && id != &SupportProtocols::RelayV2.protocol_id()
+                                    } else {
+                                        id != &SupportProtocols::Feeler.protocol_id()
+                                    }
                                 })),
                             )
                             .await;

network/src/protocols/mod.rs

@@ -35,12 +35,14 @@ pub type BoxedFutureTask = Pin<Box<dyn Future<Output = ()> + 'static + Send>>;
 use crate::{
     compress::{compress, decompress},
     network::{async_disconnect_with_message, disconnect_with_message},
-    Behaviour, Error, NetworkState, Peer, ProtocolVersion,
+    Behaviour, Error, NetworkState, Peer, ProtocolVersion, SupportProtocols,
 };
 
 /// Abstract protocol context
 #[async_trait]
 pub trait CKBProtocolContext: Send {
+    /// Get ckb2023 flag
+    fn ckb2023(&self) -> bool;
     /// Set notify to tentacle
     // Interact with underlying p2p service
     async fn set_notify(&self, interval: Duration, token: u64) -> Result<(), Error>;
@@ -283,6 +285,22 @@ impl ServiceProtocol for CKBHandler {
     }
 
     async fn connected(&mut self, context: ProtocolContextMutRef<'_>, version: &str) {
+        // This judgment will be removed in the first release after 2023 hardfork
+        if self
+            .network_state
+            .ckb2023
+            .load(std::sync::atomic::Ordering::SeqCst)
+            && version != "3"
+            && context.proto_id != SupportProtocols::RelayV2.protocol_id()
+        {
+            debug!(
+                "session {}, protocol {} with version {}, not 3, so disconnect it",
+                context.session.id, context.proto_id, version
+            );
+            let id = context.session.id;
+            let _ignore = context.disconnect(id);
+            return;
+        }
         self.network_state.with_peer_registry_mut(|reg| {
             if let Some(peer) = reg.get_peer_mut(context.session.id) {
                 peer.protocols.insert(self.proto_id, version.to_owned());
@@ -381,6 +399,11 @@ struct DefaultCKBProtocolContext {
 
 #[async_trait]
 impl CKBProtocolContext for DefaultCKBProtocolContext {
+    fn ckb2023(&self) -> bool {
+        self.network_state
+            .ckb2023
+            .load(std::sync::atomic::Ordering::SeqCst)
+    }
     async fn set_notify(&self, interval: Duration, token: u64) -> Result<(), Error> {
         self.async_p2p_control
             .set_service_notify(self.proto_id, interval, token)