feat(hubble): support bond/unbond - bond/unbond events

Author: qlp

hubble/.sqlx/query-070e308d1ff5bbe001276ede0f5acdd81c60321c63772011448b2bb49e0d6ad8.json

@@ -309,6 +309,8 @@ fn should_trigger_enrich_reset(kind: RecordKind) -> bool {
         CreateWrappedToken => false,
         CreateWrappedTokenRelation => false,
         CreateProxyAccount => false,
+        Bond => false,
+        Unbond => false,
         // ignore enriched records
         PacketSendDecoded => false,
         PacketSendTransfers => false,

hubble/.sqlx/query-933fed658c09cbddd786b478a9cea0685c70180f28f7d1742bd9f6526b97e5b7.json

@@ -0,0 +1,67 @@
+use serde::{Deserialize, Serialize};
+
+use crate::indexer::event::{
+    header::Header,
+    types::{BondInAmount, BondMintAmount, BondMintToAddress, BondSenderAddress},
+};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct BondEvent {
+    #[serde(flatten)]
+    pub header: Header,
+    pub in_amount: BondInAmount,
+    pub mint_amount: BondMintAmount,
+    pub mint_to_address: BondMintToAddress,
+    pub sender: BondSenderAddress,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::indexer::event::test_utils::test_helpers::{
+        create_bond_test_values, create_test_header, test_json_format, test_roundtrip_serialization,
+    };
+
+    /// Creates a test BondEvent with predictable values
+    fn create_test_event(suffix: u32) -> BondEvent {
+        let header = create_test_header(suffix);
+        let (in_amount, mint_amount, mint_to_address, sender) = create_bond_test_values(42);
+
+        BondEvent {
+            header,
+            in_amount,
+            mint_amount,
+            mint_to_address,
+            sender,
+        }
+    }
+
+    #[test]
+    fn test_json_serialization() {
+        let event = create_test_event(42);
+        test_roundtrip_serialization(&event);
+    }
+
+    #[test]
+    fn test_json_format_stability() {
+        let event = create_test_event(42);
+
+        let expected_json = r#"{
+            "block_hash": "0x424c4f434b5f484153485f3432",
+            "event_index": "42",
+            "height": "10042",
+            "in_amount": "542",
+            "message_index": "542",
+            "mint_amount": "1042",
+            "mint_to_address": "0x626f6e642d6d696e742d746f2d3432",
+            "sender": "0x626f6e642d73656e6465722d3432",
+            "timestamp": "2020-09-13T12:27:22Z",
+            "transaction_event_index": "242",
+            "transaction_hash": "0x54585f484153485f3432",
+            "transaction_index": "142",
+            "universal_chain_id": "test-chain-42"
+        }"#;
+
+        test_json_format(&event, expected_json);
+    }
+}

hubble/.sqlx/query-b76aced4d9e0e1e097b2254f0e1e5a26bf94e28d62bd4e4b75ee05ecc08becab.json

@@ -1,3 +1,4 @@
+pub(crate) mod bond_event;
 pub(crate) mod channel_open_ack_event;
 pub(crate) mod channel_open_confirm_event;
 pub(crate) mod channel_open_init_event;
@@ -21,6 +22,7 @@ pub(crate) mod supported;
 pub(crate) mod test_utils;
 pub(crate) mod token_bucket_update_event;
 pub(crate) mod types;
+pub(crate) mod unbond_event;
 pub(crate) mod update_client_event;
 pub(crate) mod wallet_mutation_entry_event;
 pub(crate) mod write_ack_event;

hubble/.sqlx/query-fe7a205435d15425e739fefe1933316052f3824ef30b264b5fd119fcdfc4dd43.json

@@ -3,7 +3,7 @@ use serde_json::Value;
 use time::OffsetDateTime;
 
 use crate::indexer::event::{
-    channel_open_ack_event::ChannelOpenAckEvent,
+    bond_event::BondEvent, channel_open_ack_event::ChannelOpenAckEvent,
     channel_open_confirm_event::ChannelOpenConfirmEvent,
     channel_open_init_event::ChannelOpenInitEvent, channel_open_try_event::ChannelOpenTryEvent,
     connection_open_ack_event::ConnectionOpenAckEvent,
@@ -15,7 +15,7 @@ use crate::indexer::event::{
     create_wrapped_token::CreateWrappedTokenEvent, packet_ack_event::PacketAckEvent,
     packet_recv_event::PacketRecvEvent, packet_send_event::PacketSendEvent,
     packet_timeout_event::PacketTimeoutEvent, token_bucket_update_event::TokenBucketUpdateEvent,
-    types::BlockHeight, update_client_event::UpdateClientEvent,
+    types::BlockHeight, unbond_event::UnbondEvent, update_client_event::UpdateClientEvent,
     wallet_mutation_entry_event::WalletMutationEntryEvent, write_ack_event::WriteAckEvent,
 };
 
@@ -180,6 +180,16 @@ pub enum SupportedBlockEvent {
         #[serde(flatten)]
         inner: CreateProxyAccountEvent,
     },
+    #[serde(rename = "bond")]
+    Bond {
+        #[serde(flatten)]
+        inner: BondEvent,
+    },
+    #[serde(rename = "unbond")]
+    Unbond {
+        #[serde(flatten)]
+        inner: UnbondEvent,
+    },
 }
 
 impl SupportedBlockEvent {
@@ -210,6 +220,8 @@ impl SupportedBlockEvent {
             SupportedBlockEvent::WalletMutationEntry { inner, .. } => inner.header.height,
             SupportedBlockEvent::CreateWrappedToken { inner, .. } => inner.header.height,
             SupportedBlockEvent::CreateProxyAccount { inner, .. } => inner.header.height,
+            SupportedBlockEvent::Bond { inner, .. } => inner.header.height,
+            SupportedBlockEvent::Unbond { inner, .. } => inner.header.height,
         }
     }
 }

hubble/src/indexer/consumer.rs

@@ -7,11 +7,13 @@ pub mod test_helpers {
     use crate::indexer::event::{
         header::Header,
         types::{
-            Acknowledgement, BlockHash, BlockHeight, BlockTimestamp, CanonicalChainId, Capacity,
+            Acknowledgement, Batch, BlockHash, BlockHeight, BlockTimestamp, BondInAmount,
+            BondMintAmount, BondMintToAddress, BondSenderAddress, CanonicalChainId, Capacity,
             ChannelId, ClientId, ClientType, ConnectionId, ContractAddress, Denom, EventIndex,
             Maker, MakerMsg, MessageIndex, MutationAmount, MutationDirection, PacketData,
             PacketHash, PortId, RefillRate, TimeoutTimestamp, TransactionEventIndex,
-            TransactionHash, TransactionIndex, UniversalChainId, WalletAddress,
+            TransactionHash, TransactionIndex, UnbondAmount, UnbondIsNewRequest,
+            UnbondStakerAddress, UniversalChainId, WalletAddress,
         },
     };
 
@@ -236,4 +238,33 @@ pub mod test_helpers {
             MutationDirection::In,
         )
     }
+
+    /// Creates test values for bond events
+    pub fn create_bond_test_values(
+        suffix: u32,
+    ) -> (
+        BondInAmount,
+        BondMintAmount,
+        BondMintToAddress,
+        BondSenderAddress,
+    ) {
+        (
+            BondInAmount(suffix as u128 + 500),
+            BondMintAmount(suffix as u128 + 1000),
+            BondMintToAddress(Bytes::from(format!("bond-mint-to-{suffix}"))),
+            BondSenderAddress(Bytes::from(format!("bond-sender-{suffix}"))),
+        )
+    }
+
+    /// Creates test values for unbond events
+    pub fn create_unbond_test_values(
+        suffix: u32,
+    ) -> (UnbondAmount, Batch, UnbondIsNewRequest, UnbondStakerAddress) {
+        (
+            UnbondAmount(suffix as u128 + 500),
+            Batch(suffix as u64 + 1000),
+            UnbondIsNewRequest(true),
+            UnbondStakerAddress(Bytes::from(format!("unbond-staker-{suffix}"))),
+        )
+    }
 }

hubble/src/indexer/event/bond_event.rs

@@ -496,6 +496,24 @@ impl From<u64> for MessageIndex {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Batch(#[serde(with = "flexible_u64")] pub u64);
+
+impl From<u64> for Batch {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct UnbondIsNewRequest(#[serde(with = "flexible_bool")] pub bool);
+
+impl From<bool> for UnbondIsNewRequest {
+    fn from(value: bool) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct TransactionEventIndex(#[serde(with = "flexible_u64")] pub u64);
 
@@ -591,6 +609,33 @@ impl From<bytes::Bytes> for WalletAddress {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct BondMintToAddress(#[serde(with = "bytes_as_hex")] pub bytes::Bytes);
+
+impl From<bytes::Bytes> for BondMintToAddress {
+    fn from(value: bytes::Bytes) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct UnbondStakerAddress(#[serde(with = "bytes_as_hex")] pub bytes::Bytes);
+
+impl From<bytes::Bytes> for UnbondStakerAddress {
+    fn from(value: bytes::Bytes) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct BondSenderAddress(#[serde(with = "bytes_as_hex")] pub bytes::Bytes);
+
+impl From<bytes::Bytes> for BondSenderAddress {
+    fn from(value: bytes::Bytes) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct MutationAmount(#[serde(with = "flexible_u128")] pub u128);
 
@@ -608,6 +653,33 @@ pub enum MutationDirection {
     Out,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BondInAmount(#[serde(with = "flexible_u128")] pub u128);
+
+impl From<u128> for BondInAmount {
+    fn from(value: u128) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BondMintAmount(#[serde(with = "flexible_u128")] pub u128);
+
+impl From<u128> for BondMintAmount {
+    fn from(value: u128) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct UnbondAmount(#[serde(with = "flexible_u128")] pub u128);
+
+impl From<u128> for UnbondAmount {
+    fn from(value: u128) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Path(pub U256);
 
@@ -617,6 +689,29 @@ impl From<U256> for Path {
     }
 }
 
+mod flexible_bool {
+    use super::*;
+
+    pub fn serialize<S>(value: &bool, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_bool(*value)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<bool, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = Value::deserialize(deserializer)?;
+        match value {
+            Value::Bool(b) => Ok(b),
+            Value::String(s) => s.parse().map_err(serde::de::Error::custom),
+            _ => Err(serde::de::Error::custom("expected bool or string")),
+        }
+    }
+}
+
 mod flexible_u64 {
     use super::*;