Merge pull request #4 from octopus-network/support-cleaning-state

riversyang · web-flow · commit 304b0d36c427 · 2023-05-31T13:25:28.000+08:00
Support cleaning state and add a view function.
diff --git a/near-ibc/src/context.rs b/near-ibc/src/context.rs
@@ -94,3 +94,60 @@ impl Debug for NearIbcStore {
         write!(f, "NearIbcStore {{ ... }}")
     }
 }
+
+impl NearIbcStore {
+    ///
+    pub fn remove_client(&mut self, client_id: &ClientId) {
+        if let Some(vector) = self.client_connections.get_mut(client_id) {
+            vector.clear();
+        }
+        self.client_connections.remove(client_id);
+        if let Some(queue) = self.client_processed_heights.get_mut(client_id) {
+            queue.clear();
+        }
+        self.client_processed_heights.remove(client_id);
+        if let Some(queue) = self.client_processed_times.get_mut(client_id) {
+            queue.clear();
+        }
+        self.client_processed_times.remove(client_id);
+        if let Some(queue) = self.consensus_states.get_mut(client_id) {
+            queue.clear();
+        }
+        self.consensus_states.remove(client_id);
+        self.client_states.remove(client_id);
+        self.client_types.remove(client_id);
+    }
+    ///
+    pub fn remove_connection(&mut self, connection_id: &ConnectionId) {
+        if let Some(vector) = self.connection_channels.get_mut(connection_id) {
+            vector.clear();
+        }
+        self.connection_channels.remove(connection_id);
+        self.connections.remove(connection_id);
+    }
+    ///
+    pub fn remove_channel(&mut self, channel_end: &(PortId, ChannelId)) {
+        if let Some(queue) = self.packet_receipts.get_mut(channel_end) {
+            queue.clear();
+        }
+        self.packet_receipts.remove(channel_end);
+        if let Some(queue) = self.packet_commitments.get_mut(channel_end) {
+            queue.clear();
+        }
+        self.packet_commitments.remove(channel_end);
+        if let Some(queue) = self.packet_acknowledgements.get_mut(channel_end) {
+            queue.clear();
+        }
+        self.packet_acknowledgements.remove(channel_end);
+        self.next_sequence_send.remove(channel_end);
+        self.next_sequence_recv.remove(channel_end);
+        self.next_sequence_ack.remove(channel_end);
+        self.channels.remove(channel_end);
+    }
+    ///
+    pub fn clear_counters(&mut self) {
+        self.client_ids_counter = 0;
+        self.connection_ids_counter = 0;
+        self.channel_ids_counter = 0;
+    }
+}
diff --git a/near-ibc/src/indexed_lookup_queue.rs b/near-ibc/src/indexed_lookup_queue.rs
@@ -108,14 +108,14 @@ where
         for index in self.start_index..self.end_index + 1 {
             if let Some(key) = self.index_map.get(&index) {
                 env::storage_remove(
-                    migration::get_storage_key_in_lookup_array(
+                    migration::get_storage_key_of_lookup_map(
                         &StorageKey::IbcEventsHistoryKey,
                         &key,
                     )
                     .as_slice(),
                 );
                 env::storage_remove(
-                    migration::get_storage_key_in_lookup_array(
+                    migration::get_storage_key_of_lookup_map(
                         &StorageKey::IbcEventsHistoryIndex,
                         &index,
                     )
@@ -146,6 +146,10 @@ where
     pub fn max_length(&self) -> u64 {
         self.max_length
     }
+    ///
+    pub fn latest_key(&self) -> Option<K> {
+        self.index_map.get(&self.end_index).map(|k| k.clone())
+    }
     /// Get current length of the queue.
     pub fn len(&self) -> u64 {
         if self.end_index < self.start_index {
diff --git a/near-ibc/src/lib.rs b/near-ibc/src/lib.rs
@@ -48,6 +48,8 @@ pub mod events;
 pub mod ibc_impl;
 pub mod indexed_lookup_queue;
 pub mod migration;
+pub mod testnet_functions;
+pub mod types;
 pub mod viewer;
 
 pub const DEFAULT_COMMITMENT_PREFIX: &str = "ibc";
@@ -174,7 +176,8 @@ impl Contract {
     pub fn deliver(&mut self, messages: Vec<Any>) {
         assert!(
             env::attached_deposit() >= utils::MINIMUM_DEPOSIT_FOR_DELEVER_MSG,
-            "Need to attach at least 0.1 NEAR to cover the possible storage cost."
+            "Need to attach at least {} yocto NEAR to cover the possible storage cost.",
+            utils::MINIMUM_DEPOSIT_FOR_DELEVER_MSG
         );
         let used_bytes = env::storage_usage();
         // Deliver messages to `ibc-rs`
diff --git a/near-ibc/src/migration.rs b/near-ibc/src/migration.rs
@@ -28,9 +28,6 @@ impl Contract {
     }
 }
 
-pub fn get_storage_key_in_lookup_array<T: BorshSerialize>(
-    prefix: &StorageKey,
-    index: &T,
-) -> Vec<u8> {
+pub fn get_storage_key_of_lookup_map<T: BorshSerialize>(prefix: &StorageKey, index: &T) -> Vec<u8> {
     [prefix.try_to_vec().unwrap(), index.try_to_vec().unwrap()].concat()
 }
diff --git a/near-ibc/src/testnet_functions.rs b/near-ibc/src/testnet_functions.rs
@@ -0,0 +1,64 @@
+use crate::{viewer::Viewer, *};
+use near_sdk::near_bindgen;
+
+///
+fn assert_testnet() {
+    assert!(
+        env::current_account_id().to_string().ends_with("testnet"),
+        "This method is only available on testnet"
+    );
+}
+
+#[near_bindgen]
+impl Contract {
+    ///
+    pub fn clear_ibc_events_history(&mut self) {
+        assert_testnet();
+        self.assert_governance();
+        self.ibc_events_history.clear();
+    }
+    ///
+    pub fn clear_ibc_store_counters(&mut self) {
+        assert_testnet();
+        self.assert_governance();
+        let mut near_ibc_store = self.near_ibc_store.get().unwrap();
+        near_ibc_store.clear_counters();
+        self.near_ibc_store.set(&near_ibc_store);
+    }
+    ///
+    pub fn remove_client(&mut self, client_id: ClientId) {
+        assert_testnet();
+        self.assert_governance();
+        let mut near_ibc_store = self.near_ibc_store.get().unwrap();
+        let connections = self.get_client_connections(client_id.clone());
+        for connection_id in connections {
+            let channels = self.get_connection_channels(connection_id.clone());
+            for channel in channels {
+                near_ibc_store.remove_channel(&(channel.port_id, channel.channel_id));
+            }
+            near_ibc_store.remove_connection(&connection_id);
+        }
+        near_ibc_store.remove_client(&client_id);
+        self.near_ibc_store.set(&near_ibc_store);
+    }
+    ///
+    pub fn remove_connection(&mut self, connection_id: ConnectionId) {
+        assert_testnet();
+        self.assert_governance();
+        let mut near_ibc_store = self.near_ibc_store.get().unwrap();
+        let channels = self.get_connection_channels(connection_id.clone());
+        for channel in channels {
+            near_ibc_store.remove_channel(&(channel.port_id, channel.channel_id));
+        }
+        near_ibc_store.remove_connection(&connection_id);
+        self.near_ibc_store.set(&near_ibc_store);
+    }
+    ///
+    pub fn remove_channel(&mut self, channel_end: (PortId, ChannelId)) {
+        assert_testnet();
+        self.assert_governance();
+        let mut near_ibc_store = self.near_ibc_store.get().unwrap();
+        near_ibc_store.remove_channel(&channel_end);
+        self.near_ibc_store.set(&near_ibc_store);
+    }
+}
diff --git a/near-ibc/src/types.rs b/near-ibc/src/types.rs
@@ -0,0 +1,35 @@
+use ibc::{
+    core::{
+        ics04_channel::packet::Sequence,
+        ics24_host::identifier::{ChannelId, PortId},
+    },
+    events::WithBlockDataType,
+    Height,
+};
+use near_sdk::serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(crate = "near_sdk::serde")]
+pub enum QueryHeight {
+    Latest,
+    Specific(Height),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(crate = "near_sdk::serde")]
+pub enum Qualified<T> {
+    SmallerEqual(T),
+    Equal(T),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(crate = "near_sdk::serde")]
+pub struct QueryPacketEventDataRequest {
+    pub event_id: WithBlockDataType,
+    pub source_channel_id: ChannelId,
+    pub source_port_id: PortId,
+    pub destination_channel_id: ChannelId,
+    pub destination_port_id: PortId,
+    pub sequences: Vec<Sequence>,
+    pub height: Qualified<QueryHeight>,
+}
diff --git a/near-ibc/src/viewer.rs b/near-ibc/src/viewer.rs
@@ -1,5 +1,7 @@
-use crate::Contract;
+use crate::types::{Qualified, QueryHeight};
 use crate::*;
+use crate::{types::QueryPacketEventDataRequest, Contract};
+use ibc::events::{IbcEventType, WithBlockDataType};
 use ibc::{
     core::{
         ics03_connection::connection::{ConnectionEnd, IdentifiedConnectionEnd},
@@ -13,7 +15,6 @@ use ibc::{
     },
     Height,
 };
-use ibc_proto::ibc::core::channel::v1::QueryChannelsRequest;
 
 pub trait Viewer {
     /// Get the latest height of the host chain.
@@ -48,7 +49,7 @@ pub trait Viewer {
     /// Get all connections associated with the given client id.
     fn get_client_connections(&self, client_id: ClientId) -> Vec<ConnectionId>;
     /// Get the channel ends associated with the given query request.
-    fn get_channels(&self, request: QueryChannelsRequest) -> Vec<IdentifiedChannelEnd>;
+    fn get_channels(&self) -> Vec<IdentifiedChannelEnd>;
     /// Get the channel ends associated with the given connection id.
     fn get_connection_channels(&self, connection_id: ConnectionId) -> Vec<IdentifiedChannelEnd>;
     /// Get the packet commitment stored on this host.
@@ -74,6 +75,11 @@ pub trait Viewer {
     fn get_packet_acknowledgements(&self, port_id: PortId, channel_id: ChannelId) -> Vec<Sequence>;
     /// Get the commitment packet stored on this host.
     fn get_commitment_prefix(&self) -> CommitmentPrefix;
+    /// Get the packet events associated with the given query request.
+    fn get_packet_events(
+        &self,
+        request: QueryPacketEventDataRequest,
+    ) -> Vec<(Height, Vec<IbcEvent>)>;
     /// Get the heights that ibc events happened on.
     fn get_ibc_events_heights(&self) -> Vec<u64>;
     /// Get ibc events happened on the given height.
@@ -236,7 +242,7 @@ impl Viewer for Contract {
             )
     }
 
-    fn get_channels(&self, request: QueryChannelsRequest) -> Vec<IdentifiedChannelEnd> {
+    fn get_channels(&self) -> Vec<IdentifiedChannelEnd> {
         let near_ibc_store = self.near_ibc_store.get().unwrap();
         near_ibc_store
             .channels
@@ -261,6 +267,7 @@ impl Viewer for Contract {
                 |channels| {
                     channels
                         .iter()
+                        .filter(|key| near_ibc_store.channels.contains_key(key))
                         .map(|(port_id, channel_id)| IdentifiedChannelEnd {
                             port_id: port_id.clone(),
                             channel_id: channel_id.clone(),
@@ -356,6 +363,55 @@ impl Viewer for Contract {
             .unwrap_or_default()
     }
 
+    fn get_packet_events(
+        &self,
+        request: QueryPacketEventDataRequest,
+    ) -> Vec<(Height, Vec<IbcEvent>)> {
+        let mut result: Vec<(Height, Vec<IbcEvent>)> = Vec::new();
+        let (target_height, need_to_search_in_range) = match &request.height {
+            Qualified::SmallerEqual(query_height) => match query_height {
+                QueryHeight::Latest => (self.ibc_events_history.latest_key(), true),
+                QueryHeight::Specific(height) => (Some(height.revision_height()), true),
+            },
+            Qualified::Equal(query_height) => match query_height {
+                QueryHeight::Latest => (self.ibc_events_history.latest_key(), false),
+                QueryHeight::Specific(height) => (Some(height.revision_height()), false),
+            },
+        };
+        if need_to_search_in_range {
+            if let Some(height) = target_height {
+                self.ibc_events_history
+                    .keys()
+                    .iter()
+                    .filter(|key| key.is_some())
+                    .map(|key| key.unwrap())
+                    .filter(|key| *key <= height)
+                    .for_each(|key| {
+                        gether_ibc_events_with_height(
+                            &mut result,
+                            key,
+                            self.ibc_events_history
+                                .get_value_by_key(&key)
+                                .map(|events| {
+                                    Vec::<IbcEvent>::try_from_slice(&events)
+                                        .unwrap_or_else(|_| vec![])
+                                })
+                                .unwrap_or_else(|| vec![]),
+                            &request,
+                        );
+                    });
+            }
+        } else {
+            let events = self
+                .ibc_events_history
+                .get_value_by_key(&target_height.unwrap())
+                .map_or_else(|| vec![], |events| events);
+            let ibc_events = Vec::<IbcEvent>::try_from_slice(&events).unwrap_or_else(|_| vec![]);
+            gether_ibc_events_with_height(&mut result, target_height.unwrap(), ibc_events, &request)
+        }
+        result
+    }
+
     fn get_ibc_events_heights(&self) -> Vec<u64> {
         self.ibc_events_history
             .keys()
@@ -373,3 +429,47 @@ impl Viewer for Contract {
         Vec::<IbcEvent>::try_from_slice(&raw_events).unwrap_or_else(|_| vec![])
     }
 }
+
+fn gether_ibc_events_with_height(
+    result: &mut Vec<(Height, Vec<IbcEvent>)>,
+    height: u64,
+    ibc_events: Vec<IbcEvent>,
+    request: &QueryPacketEventDataRequest,
+) {
+    let events = ibc_events
+        .iter()
+        .filter(|event| match request.event_id {
+            WithBlockDataType::CreateClient => event.event_type() == IbcEventType::CreateClient,
+            WithBlockDataType::UpdateClient => event.event_type() == IbcEventType::UpdateClient,
+            WithBlockDataType::SendPacket => event.event_type() == IbcEventType::SendPacket,
+            WithBlockDataType::WriteAck => event.event_type() == IbcEventType::WriteAck,
+        })
+        .filter(|event| match event {
+            IbcEvent::CreateClient(_) => true,
+            IbcEvent::UpdateClient(_) => true,
+            IbcEvent::ReceivePacket(receive_packet) => {
+                request.source_port_id.eq(receive_packet.src_port_id())
+                    && request
+                        .source_channel_id
+                        .eq(receive_packet.src_channel_id())
+                    && request.destination_port_id.eq(receive_packet.dst_port_id())
+                    && request
+                        .destination_channel_id
+                        .eq(receive_packet.dst_channel_id())
+                    && request.sequences.contains(&receive_packet.sequence())
+            }
+            IbcEvent::WriteAcknowledgement(write_ack) => {
+                request.source_port_id.eq(write_ack.src_port_id())
+                    && request.source_channel_id.eq(write_ack.src_channel_id())
+                    && request.destination_port_id.eq(write_ack.dst_port_id())
+                    && request
+                        .destination_channel_id
+                        .eq(write_ack.dst_channel_id())
+                    && request.sequences.contains(&write_ack.sequence())
+            }
+            _ => false,
+        })
+        .map(|event| event.clone())
+        .collect_vec();
+    result.push((Height::new(0, height).unwrap(), events));
+}

Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,6 @@ impl Contract {`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`-pub fn get_storage_key_in_lookup_array<T: BorshSerialize>(`
`32`		`- prefix: &StorageKey,`
`33`		`- index: &T,`
`34`		`-) -> Vec<u8> {`
	`31`	`+pub fn get_storage_key_of_lookup_map<T: BorshSerialize>(prefix: &StorageKey, index: &T) -> Vec<u8> {`
`35`	`32`	`[prefix.try_to_vec().unwrap(), index.try_to_vec().unwrap()].concat()`
`36`	`33`	`}`