solana-ibc: remember sequence numbers of commitments in private stora…

…ge (#78)

For the sake of relayer, remember sequence numbers of packet and
acknowledgement commitments in the private storage.

This isn’t strictly necessary since the data can be read from the
trie, but that requires iterator interface which isn’t yet
implemented.  For the time being, use sets in the private storage.

solana/solana-ibc/programs/solana-ibc/src/execution_context.rs

@@ -1,3 +1,5 @@
+use alloc::collections::BTreeMap;
+
 use anchor_lang::emit;
 use anchor_lang::prelude::borsh;
 use anchor_lang::solana_program::msg;
@@ -23,7 +25,7 @@ use lib::hash::CryptoHash;
 
 use crate::client_state::AnyClientState;
 use crate::consensus_state::AnyConsensusState;
-use crate::storage::IbcStorage;
+use crate::storage::{self, IbcStorage};
 use crate::trie_key::TrieKey;
 use crate::EmitIBCEvent;
 
@@ -238,17 +240,31 @@ impl ExecutionContext for IbcStorage<'_, '_> {
         commitment: PacketCommitment,
     ) -> Result {
         msg!("store_packet_commitment({path}, {commitment:?})");
+        let mut store = self.borrow_mut();
         let trie_key = TrieKey::from(path);
         // PacketCommitment is always 32-byte long.
         let commitment = <&CryptoHash>::try_from(commitment.as_ref()).unwrap();
-        self.borrow_mut().provable.set(&trie_key, commitment).unwrap();
+        store.provable.set(&trie_key, commitment).unwrap();
+        record_packet_sequence(
+            &mut store.private.packet_commitment_sequence_sets,
+            &path.port_id,
+            &path.channel_id,
+            path.sequence,
+        );
         Ok(())
     }
 
     fn delete_packet_commitment(&mut self, path: &CommitmentPath) -> Result {
         msg!("delete_packet_commitment({path})");
+        let mut store = self.borrow_mut();
         let trie_key = TrieKey::from(path);
-        self.borrow_mut().provable.del(&trie_key).unwrap();
+        store.provable.del(&trie_key).unwrap();
+        delete_packet_sequence(
+            &mut store.private.packet_commitment_sequence_sets,
+            &path.port_id,
+            &path.channel_id,
+            path.sequence,
+        );
         Ok(())
     }
 
@@ -258,11 +274,9 @@ impl ExecutionContext for IbcStorage<'_, '_> {
         Receipt::Ok: Receipt,
     ) -> Result {
         msg!("store_packet_receipt({path}, Ok)");
+        let mut store = self.borrow_mut();
         let trie_key = TrieKey::from(path);
-        self.borrow_mut()
-            .provable
-            .set_and_seal(&trie_key, &CryptoHash::DEFAULT)
-            .unwrap();
+        store.provable.set_and_seal(&trie_key, &CryptoHash::DEFAULT).unwrap();
         Ok(())
     }
 
@@ -272,17 +286,31 @@ impl ExecutionContext for IbcStorage<'_, '_> {
         commitment: AcknowledgementCommitment,
     ) -> Result {
         msg!("store_packet_acknowledgement({path}, {commitment:?})");
+        let mut store = self.borrow_mut();
         let trie_key = TrieKey::from(path);
         // AcknowledgementCommitment is always 32-byte long.
         let commitment = <&CryptoHash>::try_from(commitment.as_ref()).unwrap();
-        self.borrow_mut().provable.set(&trie_key, commitment).unwrap();
+        store.provable.set(&trie_key, commitment).unwrap();
+        record_packet_sequence(
+            &mut store.private.packet_acknowledgement_sequence_sets,
+            &path.port_id,
+            &path.channel_id,
+            path.sequence,
+        );
         Ok(())
     }
 
     fn delete_packet_acknowledgement(&mut self, path: &AckPath) -> Result {
         msg!("delete_packet_acknowledgement({path})");
+        let mut store = self.borrow_mut();
         let trie_key = TrieKey::from(path);
-        self.borrow_mut().provable.del(&trie_key).unwrap();
+        store.provable.del(&trie_key).unwrap();
+        delete_packet_sequence(
+            &mut store.private.packet_acknowledgement_sequence_sets,
+            &path.port_id,
+            &path.channel_id,
+            path.sequence,
+        );
         Ok(())
     }
 
@@ -425,3 +453,38 @@ fn store_serialised_proof(
     }
     store_impl(trie, key, borsh::to_vec(value))
 }
+
+type SequencesMap =
+    BTreeMap<(storage::InnerPortId, storage::InnerChannelId), Vec<Sequence>>;
+
+/// Adds sequence to given per-channel set.
+fn record_packet_sequence(
+    map: &mut SequencesMap,
+    port_id: &ibc::core::ics24_host::identifier::PortId,
+    channel_id: &ibc::core::ics24_host::identifier::ChannelId,
+    sequence: Sequence,
+) {
+    let key = (port_id.to_string(), channel_id.to_string());
+    map.entry(key).or_default().push(sequence);
+}
+
+/// Removes sequence from given per-channel set.
+fn delete_packet_sequence(
+    map: &mut SequencesMap,
+    port_id: &ibc::core::ics24_host::identifier::PortId,
+    channel_id: &ibc::core::ics24_host::identifier::ChannelId,
+    sequence: Sequence,
+) {
+    use alloc::collections::btree_map::Entry;
+
+    let key = (port_id.to_string(), channel_id.to_string());
+    if let Entry::Occupied(mut entry) = map.entry(key) {
+        let set = entry.get_mut();
+        if let Some(pos) = set.iter().position(|s| *s == sequence) {
+            set.swap_remove(pos);
+            if set.is_empty() {
+                entry.remove();
+            }
+        }
+    }
+}

solana/solana-ibc/programs/solana-ibc/src/storage.rs

@@ -107,6 +107,13 @@ pub(crate) struct PrivateStorage {
     pub port_channel_id_set: Vec<(InnerPortId, InnerChannelId)>,
     pub channel_counter: u64,
 
+    /// The sequence numbers of the packet commitments.
+    pub packet_commitment_sequence_sets:
+        BTreeMap<(InnerPortId, InnerChannelId), Vec<Sequence>>,
+    /// The sequence numbers of the packet acknowledgements.
+    pub packet_acknowledgement_sequence_sets:
+        BTreeMap<(InnerPortId, InnerChannelId), Vec<Sequence>>,
+
     /// Next send, receive and ack sequence for given (port, channel).
     ///
     /// We’re storing all three sequences in a single object to reduce amount of