fix: reuse ssz helpers from charon-cluster

Author: iamquang95

crates/charon-cluster/src/ssz.rs

@@ -32,13 +32,13 @@ pub(crate) const SSZ_LEN_FORK_VERSION: usize = 4;
 /// Length of a K1 signature.
 pub(crate) const SSZ_LEN_K1_SIG: usize = 65;
 /// Length of a BLS signature.
-pub(crate) const SSZ_LEN_BLS_SIG: usize = 96;
+pub const SSZ_LEN_BLS_SIG: usize = 96;
 /// Length of a hash.
 pub(crate) const SSZ_LEN_HASH: usize = 32;
 /// Length of withdrawal credentials.
 pub(crate) const SSZ_LEN_WITHDRAW_CREDS: usize = 32;
 /// Length of a public key.
-pub(crate) const SSZ_LEN_PUB_KEY: usize = 48;
+pub const SSZ_LEN_PUB_KEY: usize = 48;
 
 /// HashFunc is a function that hashes a definition
 pub type HashFuncWithBool<T, H> = fn(&T, &mut H, bool) -> Result<(), SSZError<H>>;

crates/charon/src/obolapi/client.rs

@@ -6,7 +6,7 @@
 use std::time::Duration;
 
 use charon_cluster::lock::Lock;
-use reqwest::StatusCode;
+use reqwest::{Method, StatusCode};
 use url::Url;
 
 use crate::obolapi::error::{Error, Result};
@@ -110,14 +110,11 @@ impl Client {
 
         let status = response.status();
         if !status.is_success() {
-            let body_text = response
-                .text()
-                .await
-                .unwrap_or_else(|_| String::from("failed to read body"));
+            let body_text = response.text().await.unwrap_or_default();
 
             return Err(Error::HttpError {
-                method: "POST".to_string(),
-                status: status.as_u16(),
+                method: Method::POST,
+                status,
                 body: body_text,
             });
         }
@@ -148,14 +145,11 @@ impl Client {
                 return Err(Error::NoExit);
             }
 
-            let body_text = response
-                .text()
-                .await
-                .unwrap_or_else(|_| String::from("failed to read body"));
+            let body_text = response.text().await.unwrap_or_default();
 
             return Err(Error::HttpError {
-                method: "GET".to_string(),
-                status: status.as_u16(),
+                method: Method::GET,
+                status,
                 body: body_text,
             });
         }
@@ -187,8 +181,8 @@ impl Client {
                 return Err(Error::NoExit);
             }
             return Err(Error::HttpError {
-                method: "DELETE".to_string(),
-                status: status.as_u16(),
+                method: Method::default(),
+                status,
                 body: String::new(),
             });
         }

crates/charon/src/obolapi/error.rs

@@ -1,5 +1,7 @@
 //! Error types for the Obol API client.
 
+use reqwest::{Method, StatusCode};
+
 /// Result type for Obol API operations.
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -14,9 +16,9 @@ pub enum Error {
     #[error("HTTP {method} request failed: status {status}, body: {body}")]
     HttpError {
         /// HTTP method (GET, POST, DELETE).
-        method: String,
+        method: Method,
         /// HTTP status code.
-        status: u16,
+        status: StatusCode,
         /// Response body.
         body: String,
     },
@@ -37,15 +39,6 @@ pub enum Error {
     #[error("hex decoding error: {0}")]
     HexDecode(#[from] hex::FromHexError),
 
-    /// Invalid hex string length.
-    #[error("invalid hex length: expected {expected} bytes, got {actual} bytes")]
-    InvalidHexLength {
-        /// Expected length in bytes.
-        expected: usize,
-        /// Actual length in bytes.
-        actual: usize,
-    },
-
     /// Empty hex string.
     #[error("empty hex string")]
     EmptyHex,

crates/charon/src/obolapi/exit.rs

@@ -9,7 +9,8 @@ use charon_crypto::{blst_impl::BlstImpl, tbls::Tbls, types::Signature};
 use serde::{Deserialize, Serialize};
 
 use charon_cluster::{
-    helpers::left_pad,
+    helpers::to_0x_hex,
+    ssz::{SSZ_LEN_BLS_SIG, SSZ_LEN_PUB_KEY},
     ssz_hasher::{HashWalker, Hasher},
 };
 use eth2api::types::{
@@ -19,12 +20,15 @@ use eth2api::types::{
 use crate::obolapi::{
     client::Client,
     error::{Error, Result},
-    helper::{bearer_string, from_0x, to_0x},
+    helper::{bearer_string, from_0x},
 };
 
 /// Type alias for signed voluntary exit from eth2api.
 pub type SignedVoluntaryExit = GetPoolVoluntaryExitsResponseResponseDatum;
 
+// TODO: Unify SSZ hashing across the workspace. `charon-cluster` already has
+// SSZ hashing utilities. Consider extracting a shared SSZ crate (or promoting
+// the existing hasher) so all crates share one SSZ interface and error type.
 /// Trait for types that can be hashed using SSZ hash tree root.
 pub trait SszHashable {
     /// Hashes this value into the provided hasher.
@@ -44,7 +48,7 @@ impl SszHashable for SignedVoluntaryExit {
 
         self.message.hash_with(hh)?;
         let sig_bytes = from_0x(&self.signature, SSZ_LEN_BLS_SIG)?;
-        put_bytes_n(hh, &sig_bytes, SSZ_LEN_BLS_SIG)?;
+        charon_cluster::helpers::put_bytes_n(hh, &sig_bytes, SSZ_LEN_BLS_SIG)?;
 
         hh.merkleize(index)?;
         Ok(())
@@ -190,7 +194,7 @@ impl From<PartialExitRequest> for PartialExitRequestDto {
     fn from(req: PartialExitRequest) -> Self {
         Self {
             unsigned: req.unsigned,
-            signature: to_0x(&req.signature),
+            signature: to_0x_hex(&req.signature),
         }
     }
 }
@@ -232,16 +236,14 @@ impl SszHashable for FullExitAuthBlob {
         let index = hh.index();
 
         hh.put_bytes(&self.lock_hash)?;
-        put_bytes_n(hh, &self.validator_pubkey, SSZ_LEN_PUB_KEY)?;
+        charon_cluster::helpers::put_bytes_n(hh, &self.validator_pubkey, SSZ_LEN_PUB_KEY)?;
         hh.put_uint64(self.share_index)?;
 
         hh.merkleize(index)?;
         Ok(())
     }
 }
 const SSZ_MAX_EXITS: usize = 65536;
-const SSZ_LEN_PUB_KEY: usize = 48;
-const SSZ_LEN_BLS_SIG: usize = 96;
 
 impl Client {
     /// Posts the set of msg's to the Obol API, for a given lock hash.
@@ -253,7 +255,7 @@ impl Client {
         identity_key: &k256::SecretKey,
         mut exit_blobs: Vec<ExitBlob>,
     ) -> Result<()> {
-        let lock_hash_str = to_0x(lock_hash);
+        let lock_hash_str = to_0x_hex(lock_hash);
         let path = submit_partial_exit_url(&lock_hash_str);
 
         let url = self.build_url(&path)?;
@@ -300,7 +302,7 @@ impl Client {
         // Validate public key is 48 bytes
         let val_pubkey_bytes = from_0x(val_pubkey, 48)?;
 
-        let path = fetch_full_exit_url(val_pubkey, &to_0x(lock_hash), share_index);
+        let path = fetch_full_exit_url(val_pubkey, &to_0x_hex(lock_hash), share_index);
 
         let url = self.build_url(&path)?;
 
@@ -362,7 +364,7 @@ impl Client {
                     epoch: epoch_u64.to_string(),
                     validator_index: exit_response.validator_index.to_string(),
                 },
-                signature: to_0x(&full_sig),
+                signature: to_0x_hex(&full_sig),
             },
         })
     }
@@ -380,7 +382,7 @@ impl Client {
         // Validate public key is 48 bytes
         let val_pubkey_bytes = from_0x(val_pubkey, 48)?;
 
-        let path = delete_partial_exit_url(val_pubkey, &to_0x(lock_hash), share_index);
+        let path = delete_partial_exit_url(val_pubkey, &to_0x_hex(lock_hash), share_index);
 
         let url = self.build_url(&path)?;
 
@@ -423,19 +425,6 @@ fn fetch_full_exit_url(val_pubkey: &str, lock_hash: &str, share_index: u64) -> S
     format!("/exp/exit/{}/{}/{}", lock_hash, share_index, val_pubkey)
 }
 
-fn put_bytes_n(hh: &mut Hasher, bytes: &[u8], expected_len: usize) -> Result<()> {
-    if bytes.len() > expected_len {
-        use charon_cluster::ssz::SSZError;
-        return Err(Error::Ssz(SSZError::UnsupportedVersion(format!(
-            "bytes too long: expected {}, got {}",
-            expected_len,
-            bytes.len()
-        ))));
-    }
-    let padded: Vec<u8> = left_pad(bytes, expected_len);
-    Ok(hh.put_bytes(&padded)?)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -486,7 +475,7 @@ mod tests {
 404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f";
 
         let exit_blob = ExitBlob {
-            public_key: Some(to_0x(&validator_pubkey)),
+            public_key: Some(to_0x_hex(&validator_pubkey)),
             signed_exit_message: SignedVoluntaryExit {
                 message: Phase0SignedVoluntaryExitMessage {
                     epoch: "194048".to_string(),

crates/charon/src/obolapi/helper.rs

@@ -1,39 +1,22 @@
-//! Serialization helpers for hex encoding/decoding with 0x prefix.
-//!
-//! These helpers match the behavior of the Go implementation for handling
-//! hex-encoded data with optional 0x prefixes and strict length validation.
+use charon_cluster::helpers::to_0x_hex;
 
 use crate::obolapi::error::{Error, Result};
 
 /// Decodes a hex-encoded string and expects it to be exactly `expected_len`
 /// bytes. Accepts both 0x-prefixed strings and plain hex strings.
-pub fn from_0x(data: &str, expected_len: usize) -> Result<Vec<u8>> {
+pub(crate) fn from_0x(data: &str, expected_len: usize) -> Result<Vec<u8>> {
     if data.is_empty() {
         return Err(Error::EmptyHex);
     }
-
-    let hex_str = data.strip_prefix("0x").unwrap_or(data);
-    let bytes = hex::decode(hex_str)?;
-
-    if bytes.len() != expected_len {
-        return Err(Error::InvalidHexLength {
-            expected: expected_len,
-            actual: bytes.len(),
-        });
-    }
-
-    Ok(bytes)
-}
-
-/// Encodes bytes to a hex string with 0x prefix.
-/// Uses lowercase hex encoding and includes the 0x prefix.
-pub fn to_0x(data: &[u8]) -> String {
-    format!("0x{}", hex::encode(data))
+    Ok(charon_cluster::helpers::from_0x_hex_str(
+        data,
+        expected_len,
+    )?)
 }
 
 /// Formats bytes as a bearer token string.
-pub fn bearer_string(data: &[u8]) -> String {
-    format!("Bearer {}", to_0x(data))
+pub(crate) fn bearer_string(data: &[u8]) -> String {
+    format!("Bearer {}", to_0x_hex(data))
 }
 
 #[cfg(test)]
@@ -61,13 +44,7 @@ mod tests {
     #[test]
     fn test_from_0x_wrong_length() {
         let result = from_0x("0x1234", 3);
-        assert!(matches!(result, Err(Error::InvalidHexLength { .. })));
-    }
-
-    #[test]
-    fn test_to_0x() {
-        let hex = to_0x(&[0x12, 0x34]);
-        assert_eq!(hex, "0x1234");
+        assert!(result.is_err());
     }
 
     #[test]

crates/charon/src/obolapi/mod.rs

@@ -3,7 +3,7 @@
 mod client;
 mod error;
 mod helper;
-mod test_api;
+mod test;
 
 pub mod exit;
 pub mod publish;

crates/charon/src/obolapi/publish.rs

@@ -6,11 +6,9 @@
 use charon_cluster::lock::Lock;
 use serde::{Deserialize, Serialize};
 
-use crate::obolapi::{
-    client::Client,
-    error::Result,
-    helper::{bearer_string, to_0x},
-};
+use charon_cluster::helpers::to_0x_hex;
+
+use crate::obolapi::{client::Client, error::Result, helper::bearer_string};
 
 /// Request to sign Obol's Terms and Conditions.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -88,7 +86,7 @@ impl Client {
             address: user_addr.to_string(),
             version: 1,
             terms_and_conditions_hash: TERMS_AND_CONDITIONS_HASH.to_string(),
-            fork_version: to_0x(fork_version),
+            fork_version: to_0x_hex(fork_version),
         };
 
         let body = serde_json::to_vec(&request)?;