initial trait

Author: vaporif

Cargo.lock

@@ -1,26 +1,54 @@
-[package]
-name = "mercury"
+[workspace]
+resolver = "2"
+
+members = [
+    "crates/core",
+    "crates/chain-traits",
+    "crates/cosmos",
+    "crates/relay",
+    "crates/cli",
+]
+
+[workspace.package]
 version = "0.1.0"
 edition = "2024"
-description = ""
 license = "MIT"
 repository = "https://github.com/vaporif/mercury"
-readme = "README.md"
 
-[lints.clippy]
+[workspace.lints.clippy]
 all = { level = "warn", priority = -1 }
 pedantic = { level = "warn", priority = -1 }
 nursery = { level = "warn", priority = -1 }
 cargo = { level = "warn", priority = -1 }
 multiple_crate_versions = "allow"
 
-[dependencies]
-tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }
-thiserror = "2"
-clap = { version = "4", features = ["derive", "env"] }
+[workspace.dependencies]
+async-trait = "0.1"
+eyre = "0.6"
+tracing = "0.1"
+tokio = { version = "1", features = ["full"] }
+futures = { version = "0.3", default-features = false }
+clap = { version = "4", features = ["derive"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
-[dev-dependencies]
+mercury-core = { path = "crates/core" }
+mercury-chain-traits = { path = "crates/chain-traits" }
+mercury-cosmos = { path = "crates/cosmos" }
+mercury-relay = { path = "crates/relay" }
+mercury-cli = { path = "crates/cli" }
+
+tendermint = { version = "0.40", features = ["secp256k1"] }
+tendermint-rpc = { version = "0.40", features = ["http-client"] }
+tendermint-proto = "0.40"
+tendermint-light-client-verifier = "0.40"
+ibc = { version = "0.56", default-features = false, features = ["serde"] }
+ibc-proto = { version = "0.51", default-features = false, features = ["serde"] }
+ibc-client-tendermint = { version = "0.56", default-features = false }
+prost = "0.13"
+prost-types = "0.13"
+tonic = { version = "0.12", features = ["tls", "tls-roots"] }
+secp256k1 = { version = "0.28", features = ["serde"] }
+sha2 = "0.10"
+bech32 = "0.9"

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "mercury-chain-traits"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+mercury-core = { workspace = true }
+async-trait = { workspace = true }

crates/chain-traits/Cargo.toml

@@ -0,0 +1,12 @@
+use mercury_core::ThreadSafe;
+
+use crate::types::{HasChainTypes, HasPacketTypes};
+
+pub trait CanExtractPacketEvents<Counterparty: HasChainTypes + ?Sized>:
+    HasPacketTypes<Counterparty>
+{
+    type SendPacketEvent: ThreadSafe;
+
+    fn try_extract_send_packet_event(event: &Self::Event) -> Option<Self::SendPacketEvent>;
+    fn packet_from_send_event(event: &Self::SendPacketEvent) -> &Self::Packet;
+}

crates/chain-traits/src/events.rs

@@ -0,0 +1,12 @@
+pub mod types;
+pub mod messaging;
+pub mod queries;
+pub mod packet_queries;
+pub mod payload_builders;
+pub mod message_builders;
+pub mod packet_builders;
+pub mod events;
+pub mod tx;
+pub mod relay;
+
+pub use types::*;

crates/chain-traits/src/lib.rs

@@ -0,0 +1,42 @@
+use async_trait::async_trait;
+use mercury_core::error::Result;
+
+use crate::payload_builders::{CanBuildCreateClientPayload, CanBuildUpdateClientPayload};
+use crate::types::{HasChainTypes, HasIbcTypes, HasMessageTypes};
+
+#[async_trait]
+pub trait CanBuildCreateClientMessage<Counterparty>: HasMessageTypes
+where
+    Counterparty: HasChainTypes + CanBuildCreateClientPayload<Self>,
+{
+    async fn build_create_client_message(
+        &self,
+        payload: Counterparty::CreateClientPayload,
+    ) -> Result<Self::Message>;
+}
+
+#[async_trait]
+pub trait CanBuildUpdateClientMessage<Counterparty>:
+    HasMessageTypes + HasIbcTypes<Counterparty>
+where
+    Counterparty: HasChainTypes + CanBuildUpdateClientPayload<Self>,
+{
+    async fn build_update_client_message(
+        &self,
+        client_id: &Self::ClientId,
+        payload: Counterparty::UpdateClientPayload,
+    ) -> Result<Vec<Self::Message>>;
+}
+
+#[async_trait]
+pub trait CanRegisterCounterparty<Counterparty>:
+    HasMessageTypes + HasIbcTypes<Counterparty>
+where
+    Counterparty: HasChainTypes + HasIbcTypes<Self>,
+{
+    async fn build_register_counterparty_message(
+        &self,
+        client_id: &Self::ClientId,
+        counterparty_client_id: &<Counterparty as HasIbcTypes<Self>>::ClientId,
+    ) -> Result<Self::Message>;
+}

crates/chain-traits/src/message_builders.rs

@@ -0,0 +1,12 @@
+use async_trait::async_trait;
+use mercury_core::error::Result;
+
+use crate::types::HasMessageTypes;
+
+#[async_trait]
+pub trait CanSendMessages: HasMessageTypes {
+    async fn send_messages(
+        &self,
+        messages: Vec<Self::Message>,
+    ) -> Result<Vec<Self::MessageResponse>>;
+}

crates/chain-traits/src/messaging.rs

@@ -0,0 +1,48 @@
+use async_trait::async_trait;
+use mercury_core::ThreadSafe;
+use mercury_core::error::Result;
+
+use crate::types::{HasChainTypes, HasMessageTypes, HasPacketTypes};
+
+#[async_trait]
+pub trait CanBuildReceivePacketMessage<Counterparty>:
+    HasMessageTypes + HasPacketTypes<Counterparty>
+where
+    Counterparty: HasChainTypes + HasPacketTypes<Self>,
+{
+    type ReceivePacketPayload: ThreadSafe;
+    async fn build_receive_packet_message(
+        &self,
+        packet: &<Counterparty as HasPacketTypes<Self>>::Packet,
+        payload: Self::ReceivePacketPayload,
+    ) -> Result<Self::Message>;
+}
+
+#[async_trait]
+pub trait CanBuildAckPacketMessage<Counterparty>:
+    HasMessageTypes + HasPacketTypes<Counterparty>
+where
+    Counterparty: HasChainTypes + HasPacketTypes<Self>,
+{
+    type AckPacketPayload: ThreadSafe;
+    async fn build_ack_packet_message(
+        &self,
+        packet: &Self::Packet,
+        ack: &<Counterparty as HasPacketTypes<Self>>::Acknowledgement,
+        payload: Self::AckPacketPayload,
+    ) -> Result<Self::Message>;
+}
+
+#[async_trait]
+pub trait CanBuildTimeoutPacketMessage<Counterparty>:
+    HasMessageTypes + HasPacketTypes<Counterparty>
+where
+    Counterparty: HasChainTypes + HasPacketTypes<Self>,
+{
+    type TimeoutPacketPayload: ThreadSafe;
+    async fn build_timeout_packet_message(
+        &self,
+        packet: &Self::Packet,
+        payload: Self::TimeoutPacketPayload,
+    ) -> Result<Self::Message>;
+}

crates/chain-traits/src/packet_builders.rs

@@ -0,0 +1,40 @@
+use async_trait::async_trait;
+use mercury_core::error::Result;
+
+use crate::types::{HasChainTypes, HasPacketTypes};
+
+#[async_trait]
+pub trait CanQueryPacketCommitment<Counterparty: HasChainTypes + ?Sized>:
+    HasPacketTypes<Counterparty>
+{
+    async fn query_packet_commitment(
+        &self,
+        client_id: &Self::ClientId,
+        sequence: u64,
+        height: &Self::Height,
+    ) -> Result<(Option<Self::PacketCommitment>, Self::CommitmentProof)>;
+}
+
+#[async_trait]
+pub trait CanQueryPacketReceipt<Counterparty: HasChainTypes + ?Sized>:
+    HasPacketTypes<Counterparty>
+{
+    async fn query_packet_receipt(
+        &self,
+        client_id: &Self::ClientId,
+        sequence: u64,
+        height: &Self::Height,
+    ) -> Result<(Option<Self::PacketReceipt>, Self::CommitmentProof)>;
+}
+
+#[async_trait]
+pub trait CanQueryPacketAcknowledgement<Counterparty: HasChainTypes + ?Sized>:
+    HasPacketTypes<Counterparty>
+{
+    async fn query_packet_acknowledgement(
+        &self,
+        client_id: &Self::ClientId,
+        sequence: u64,
+        height: &Self::Height,
+    ) -> Result<(Option<Self::Acknowledgement>, Self::CommitmentProof)>;
+}

crates/chain-traits/src/packet_queries.rs

@@ -0,0 +1,23 @@
+use async_trait::async_trait;
+use mercury_core::ThreadSafe;
+use mercury_core::error::Result;
+
+use crate::types::{HasChainTypes, HasIbcTypes};
+
+#[async_trait]
+pub trait CanBuildCreateClientPayload<Counterparty: HasChainTypes + ?Sized>: HasChainTypes {
+    type CreateClientPayload: ThreadSafe;
+    async fn build_create_client_payload(&self) -> Result<Self::CreateClientPayload>;
+}
+
+#[async_trait]
+pub trait CanBuildUpdateClientPayload<Counterparty: HasChainTypes + ?Sized>:
+    HasIbcTypes<Counterparty>
+{
+    type UpdateClientPayload: ThreadSafe;
+    async fn build_update_client_payload(
+        &self,
+        trusted_height: &Self::Height,
+        target_height: &Self::Height,
+    ) -> Result<Self::UpdateClientPayload>;
+}