Move Cetus Aggregator to Rust (#1123)

Author: 0xh3rman

Cargo.lock

@@ -51,6 +51,14 @@ pub trait Client: Send + Sync + Debug {
         R: DeserializeOwned;
 }
 
+pub trait ClientBounds: Client + Clone + Send + Sync + 'static {}
+
+impl<T> ClientBounds for T where T: Client + Clone + Send + Sync + 'static {}
+
+pub trait DebugClientBounds: ClientBounds + Debug {}
+
+impl<T> DebugClientBounds for T where T: ClientBounds + Debug {}
+
 #[async_trait]
 pub trait ClientExt: Client {
     async fn get<R>(&self, path: &str) -> Result<R, ClientError>

crates/gem_client/src/lib.rs

@@ -0,0 +1,68 @@
+use crate::{SUI_COIN_TYPE, SUI_COIN_TYPE_FULL};
+use primitives::hex::decode_hex;
+
+const SUI_ADDRESS_LENGTH: usize = 32;
+
+pub fn full_coin_type(coin_type: &str) -> String {
+    let Some((prefix, rest)) = coin_type.split_once("::") else {
+        return coin_type.to_string();
+    };
+    match decode_hex(prefix) {
+        Ok(bytes) if bytes.len() <= SUI_ADDRESS_LENGTH => {
+            let mut padded = [0u8; SUI_ADDRESS_LENGTH];
+            padded[SUI_ADDRESS_LENGTH - bytes.len()..].copy_from_slice(&bytes);
+            format!("0x{}::{rest}", hex::encode(padded))
+        }
+        _ => coin_type.to_string(),
+    }
+}
+
+pub fn coin_type_matches(a: &str, b: &str) -> bool {
+    full_coin_type(a) == full_coin_type(b)
+}
+
+pub fn is_sui_coin(coin_type: &str) -> bool {
+    coin_type == SUI_COIN_TYPE || coin_type == SUI_COIN_TYPE_FULL
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_full_coin_type() {
+        assert_eq!(
+            full_coin_type("0x2::sui::SUI"),
+            "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        );
+        assert_eq!(
+            full_coin_type("2::sui::SUI"),
+            "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        );
+        assert_eq!(
+            full_coin_type("0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"),
+            "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        );
+        assert_eq!(full_coin_type("0xabc"), "0xabc");
+        assert_eq!(full_coin_type("not-a-type::coin::COIN"), "not-a-type::coin::COIN");
+    }
+
+    #[test]
+    fn test_coin_type_matches() {
+        assert!(coin_type_matches("0x2::sui::SUI", "0x2::sui::SUI"));
+        assert!(coin_type_matches("0x2::sui::SUI", "2::sui::SUI"));
+        assert!(coin_type_matches("2::sui::SUI", "0x2::sui::SUI"));
+        assert!(coin_type_matches(
+            "0x2::sui::SUI",
+            "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+        ));
+        assert!(!coin_type_matches("0x2::sui::SUI", "0x3::token::TOKEN"));
+    }
+
+    #[test]
+    fn test_is_sui_coin() {
+        assert!(is_sui_coin(SUI_COIN_TYPE));
+        assert!(is_sui_coin(SUI_COIN_TYPE_FULL));
+        assert!(!is_sui_coin("0x3::token::TOKEN"));
+    }
+}

crates/gem_sui/src/coin_type.rs

@@ -0,0 +1,29 @@
+use std::{
+    error::Error,
+    fmt::{Display, Formatter},
+};
+
+#[derive(Debug)]
+pub enum SuiError {
+    InvalidInput(String),
+    InsufficientBalance,
+    NoGasCoins,
+}
+
+impl Display for SuiError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidInput(message) => write!(f, "{message}"),
+            Self::InsufficientBalance => write!(f, "insufficient Sui coin balance"),
+            Self::NoGasCoins => write!(f, "No SUI coins available for gas"),
+        }
+    }
+}
+
+impl Error for SuiError {}
+
+impl SuiError {
+    pub fn invalid_input(message: impl Into<String>) -> Self {
+        Self::InvalidInput(message.into())
+    }
+}

crates/gem_sui/src/error.rs

@@ -96,6 +96,18 @@ impl Default for ObjectDataOptions {
     }
 }
 
+impl ObjectDataOptions {
+    pub fn owner_only() -> Self {
+        Self {
+            show_type: false,
+            show_owner: true,
+            show_display: false,
+            show_content: false,
+            show_bcs: false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SuiData<T> {

crates/gem_sui/src/jsonrpc.rs

@@ -1,5 +1,7 @@
 pub mod address;
 pub use address::validate_address;
+pub mod coin_type;
+pub use coin_type::{coin_type_matches, full_coin_type, is_sui_coin};
 #[cfg(feature = "rpc")]
 pub mod rpc;
 #[cfg(feature = "rpc")]
@@ -15,18 +17,21 @@ pub mod transfer_builder;
 #[cfg(feature = "rpc")]
 pub use transfer_builder::*;
 
+pub mod error;
 pub mod gas_budget;
 pub mod jsonrpc;
-pub mod operations;
+pub mod tx_builder;
 
 #[cfg(feature = "signer")]
 pub mod signer;
 
+pub use error::SuiError;
 use models::Coin;
 pub use models::ObjectId;
-pub use operations::*;
 use std::error::Error;
 use sui_transaction_builder::ObjectInput;
+pub use tx_builder::{decode_transaction, stake::*, transfer::*, validate_and_hash};
+pub use tx_builder::{stake, transfer};
 
 pub const SUI_SYSTEM_ID: &str = "sui_system";
 

crates/gem_sui/src/lib.rs

@@ -1,9 +1,14 @@
 use num_bigint::BigInt;
 use serde::{Deserialize, Serialize};
 use serde_serializers::{deserialize_bigint_from_str, deserialize_u64_from_str, serialize_bigint, serialize_u64};
+#[cfg(feature = "rpc")]
+use std::{error::Error, str::FromStr};
 use sui_transaction_builder::ObjectInput;
 use sui_types::{Address, Digest};
 
+#[cfg(feature = "rpc")]
+use super::SuiCoin;
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CoinAsset {
@@ -22,6 +27,21 @@ impl CoinAsset {
     }
 }
 
+#[cfg(feature = "rpc")]
+impl TryFrom<SuiCoin> for CoinAsset {
+    type Error = Box<dyn Error + Send + Sync>;
+
+    fn try_from(coin: SuiCoin) -> Result<Self, Self::Error> {
+        Ok(Self {
+            coin_object_id: Address::from_str(&coin.coin_object_id)?,
+            coin_type: coin.coin_type,
+            digest: Digest::from_str(&coin.digest)?,
+            balance: coin.balance,
+            version: coin.version.parse()?,
+        })
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CoinResponse {

crates/gem_sui/src/models/coin_asset.rs

@@ -24,6 +24,7 @@ pub struct SuiTransaction {
 #[serde(rename_all = "camelCase")]
 pub struct SuiStatus {
     pub status: String,
+    pub error: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]