feat(hubble): support bond/unbond - handle create-proxy-account

Author: qlp

hubble/.sqlx/query-f1e8ab866aee99c240c2583bc6883430b89e063d6c84c33b752d84995aa017bc.json

@@ -308,6 +308,7 @@ fn should_trigger_enrich_reset(kind: RecordKind) -> bool {
         WalletMutationEntry => false,
         CreateWrappedToken => false,
         CreateWrappedTokenRelation => false,
+        CreateProxyAccount => false,
         // ignore enriched records
         PacketSendDecoded => false,
         PacketSendTransfers => false,

hubble/.sqlx/query-f2c7497b73df281bcf50dcc5d2f32a25c5f58f65f00b56b230404eedd3860ba4.json

@@ -0,0 +1,71 @@
+use serde::{Deserialize, Serialize};
+
+use crate::indexer::event::{
+    header::Header,
+    types::{ChannelId, Owner, Path, ProxyAccount},
+};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct CreateProxyAccountEvent {
+    #[serde(flatten)]
+    pub header: Header,
+    pub path: Path,
+    pub channel_id: ChannelId,
+    pub owner: Owner,
+    pub proxy_account: ProxyAccount,
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::Bytes;
+
+    use super::*;
+    use crate::indexer::event::{
+        test_utils::test_helpers::{
+            create_test_header, test_json_format, test_roundtrip_serialization,
+        },
+        types::{ChannelId, Owner, Path, ProxyAccount},
+    };
+
+    /// Creates a test CreateProxyAccountEvent with predictable values
+    fn create_test_event(suffix: u32) -> CreateProxyAccountEvent {
+        let header = create_test_header(suffix);
+
+        CreateProxyAccountEvent {
+            header,
+            channel_id: ChannelId(42),
+            path: Path(42_u128.try_into().unwrap()),
+            owner: Owner(Bytes::from("owner")),
+            proxy_account: ProxyAccount(Bytes::from("proxy_account")),
+        }
+    }
+
+    #[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",
+  "channel_id": 42,
+  "event_index": "42",
+  "height": "10042",
+  "message_index": "542",
+  "owner": "0x6f776e6572",
+  "path": "0x2a",
+  "proxy_account": "0x70726f78795f6163636f756e74",
+  "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/src/indexer/consumer.rs

@@ -8,6 +8,7 @@ pub(crate) mod connection_open_init_event;
 pub(crate) mod connection_open_try_event;
 pub(crate) mod create_client_event;
 pub(crate) mod create_lens_client_event;
+pub(crate) mod create_proxy_account_event;
 pub(crate) mod create_wrapped_token;
 pub(crate) mod header;
 pub(crate) mod hubble;

hubble/src/indexer/event/create_proxy_account_event.rs

@@ -10,12 +10,13 @@ use crate::indexer::event::{
     connection_open_confirm_event::ConnectionOpenConfirmEvent,
     connection_open_init_event::ConnectionOpenInitEvent,
     connection_open_try_event::ConnectionOpenTryEvent, create_client_event::CreateClientEvent,
-    create_lens_client_event::CreateLensClientEvent, 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, wallet_mutation_entry_event::WalletMutationEntryEvent,
-    write_ack_event::WriteAckEvent,
+    create_lens_client_event::CreateLensClientEvent,
+    create_proxy_account_event::CreateProxyAccountEvent,
+    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,
+    wallet_mutation_entry_event::WalletMutationEntryEvent, write_ack_event::WriteAckEvent,
 };
 
 #[warn(clippy::enum_variant_names)]
@@ -174,6 +175,11 @@ pub enum SupportedBlockEvent {
         #[serde(flatten)]
         inner: CreateWrappedTokenEvent,
     },
+    #[serde(rename = "create-proxy-account")]
+    CreateProxyAccount {
+        #[serde(flatten)]
+        inner: CreateProxyAccountEvent,
+    },
 }
 
 impl SupportedBlockEvent {
@@ -203,6 +209,7 @@ impl SupportedBlockEvent {
             SupportedBlockEvent::TokenBucketUpdate { inner, .. } => inner.header.height,
             SupportedBlockEvent::WalletMutationEntry { inner, .. } => inner.header.height,
             SupportedBlockEvent::CreateWrappedToken { inner, .. } => inner.header.height,
+            SupportedBlockEvent::CreateProxyAccount { inner, .. } => inner.header.height,
         }
     }
 }

hubble/src/indexer/event/mod.rs

@@ -530,6 +530,24 @@ impl From<bytes::Bytes> for Denom {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Owner(#[serde(with = "bytes_as_hex")] pub bytes::Bytes);
+
+impl From<bytes::Bytes> for Owner {
+    fn from(value: bytes::Bytes) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProxyAccount(#[serde(with = "bytes_as_hex")] pub bytes::Bytes);
+
+impl From<bytes::Bytes> for ProxyAccount {
+    fn from(value: bytes::Bytes) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Capacity(pub U256);
 

hubble/src/indexer/event/supported.rs

@@ -0,0 +1,21 @@
+use tracing::trace;
+
+use crate::indexer::{
+    api::IndexerError,
+    event::create_proxy_account_event::CreateProxyAccountEvent,
+    handler::EventContext,
+    record::{
+        change_counter::Changes, create_proxy_account_record::CreateProxyAccountRecord,
+        ChainContext,
+    },
+};
+impl<'a> EventContext<'a, ChainContext, CreateProxyAccountEvent> {
+    pub async fn handle(
+        &self,
+        tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    ) -> Result<Changes, IndexerError> {
+        trace!("handle({self:?})");
+
+        CreateProxyAccountRecord::try_from(self)?.insert(tx).await
+    }
+}

hubble/src/indexer/event/types.rs

@@ -10,6 +10,7 @@ pub(crate) mod connection_open_init_event_handler;
 pub(crate) mod connection_open_try_event_handler;
 pub(crate) mod create_client_handler;
 pub(crate) mod create_lens_client_handler;
+pub(crate) mod create_proxy_account_handler;
 pub(crate) mod create_wrapped_token_handler;
 pub(crate) mod packet_ack_event_handler;
 pub(crate) mod packet_recv_event_handler;

hubble/src/indexer/handler/create_proxy_account_handler.rs

@@ -333,6 +333,7 @@ pub enum RecordKind {
     PacketSendUnbond,
     CreateWrappedToken,
     CreateWrappedTokenRelation,
+    CreateProxyAccount,
 }
 
 /// Trait for types that can be associated with a specific `RecordKind`.