Refactor TON sign data to prepare data without signing

Author: DRadmir

Cargo.lock

@@ -119,7 +119,10 @@ mod tests {
     use primitives::delegation::DelegationValidator;
 
     fn chain_parameter(key: &str, value: i64) -> ChainParameter {
-        ChainParameter { key: key.to_string(), value: Some(value) }
+        ChainParameter {
+            key: key.to_string(),
+            value: Some(value),
+        }
     }
 
     fn account_usage(free_bandwidth: u64, staked_bandwidth: u64, available_energy: u64) -> TronAccountUsage {

crates/gem_tron/src/provider/preload_mapper.rs

@@ -14,5 +14,6 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 gem_hash = { path = "../gem_hash" }
 zeroize = { version = "1.8.2" }
+strum = { workspace = true }
 
 [dev-dependencies]

crates/signer/Cargo.toml

@@ -18,7 +18,7 @@ use crate::sui::assemble_signature;
 pub use eip712::hash_typed_data as hash_eip712;
 pub use error::SignerError;
 pub use sui::SUI_PERSONAL_MESSAGE_SIGNATURE_LEN;
-pub use ton::TonSignDataInput;
+pub use ton::{TonSignDataPayload, TonSignDataResponse, TonSignDataType};
 
 #[derive(Debug, Default)]
 pub struct Signer;
@@ -61,10 +61,6 @@ impl Signer {
         let signature = Self::sign_digest(SignatureScheme::Secp256k1, digest.to_vec(), private_key_vec.to_vec())?;
         Ok(hex::encode(signature))
     }
-
-    pub fn sign_ton_personal_message(input: TonSignDataInput, private_key: Vec<u8>) -> Result<String, SignerError> {
-        ton::sign_ton_personal_message(input, private_key)
-    }
 }
 
 #[cfg(test)]

crates/signer/src/lib.rs

@@ -1,31 +1,20 @@
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::str::FromStr;
 
-use base64::Engine;
-use base64::engine::general_purpose::STANDARD;
-use ed25519_dalek::Signer as DalekSigner;
 use serde::{Deserialize, Serialize};
-use zeroize::Zeroizing;
+use strum::{AsRefStr, EnumString};
 
-use crate::ed25519::signing_key_from_bytes;
 use crate::error::SignerError;
 
-#[derive(Clone, Debug, PartialEq)]
-enum TonSignDataType {
+#[derive(Clone, Debug, PartialEq, AsRefStr, EnumString)]
+#[strum(serialize_all = "lowercase")]
+pub enum TonSignDataType {
     Text,
     Binary,
     Cell,
 }
 
 impl TonSignDataType {
-    fn as_str(&self) -> &'static str {
-        match self {
-            TonSignDataType::Text => "text",
-            TonSignDataType::Binary => "binary",
-            TonSignDataType::Cell => "cell",
-        }
-    }
-
-    fn data_field(&self) -> &'static str {
+    pub fn data_field(&self) -> &'static str {
         match self {
             TonSignDataType::Text => "text",
             TonSignDataType::Binary => "bytes",
@@ -43,33 +32,40 @@ struct TonSignDataPayloadRaw {
     cell: Option<String>,
 }
 
-struct TonSignDataPayload {
-    payload_type: TonSignDataType,
-    data: String,
+pub struct TonSignDataPayload {
+    pub payload_type: TonSignDataType,
+    pub data: String,
 }
 
 impl TonSignDataPayload {
-    fn parse(json: &str) -> Result<Self, SignerError> {
+    pub fn parse(json: &str) -> Result<Self, SignerError> {
         let raw: TonSignDataPayloadRaw = serde_json::from_str(json)?;
 
-        let (payload_type, data) = match raw.payload_type.as_str() {
-            "text" => (TonSignDataType::Text, raw.text.ok_or("Missing text field")?),
-            "binary" => (TonSignDataType::Binary, raw.bytes.ok_or("Missing bytes field")?),
-            "cell" => (TonSignDataType::Cell, raw.cell.ok_or("Missing cell field")?),
-            _ => return Err(SignerError::new(format!("Unknown payload type: {}", raw.payload_type))),
+        let payload_type = TonSignDataType::from_str(&raw.payload_type).map_err(|_| SignerError::new(format!("Unknown payload type: {}", raw.payload_type)))?;
+
+        let data = match payload_type {
+            TonSignDataType::Text => raw.text.ok_or("Missing text field")?,
+            TonSignDataType::Binary => raw.bytes.ok_or("Missing bytes field")?,
+            TonSignDataType::Cell => raw.cell.ok_or("Missing cell field")?,
         };
 
         Ok(Self { payload_type, data })
     }
-}
 
-pub struct TonSignDataInput {
-    pub domain: String,
-    pub payload: Vec<u8>,
+    pub fn hash(&self) -> Vec<u8> {
+        self.data.as_bytes().to_vec()
+    }
+
+    pub fn to_json(&self) -> serde_json::Value {
+        serde_json::json!({
+            "type": self.payload_type.as_ref(),
+            self.payload_type.data_field(): self.data,
+        })
+    }
 }
 
 #[derive(Serialize)]
-struct TonSignDataResponse {
+pub struct TonSignDataResponse {
     signature: String,
     #[serde(rename = "publicKey")]
     public_key: String,
@@ -78,38 +74,25 @@ struct TonSignDataResponse {
     payload: serde_json::Value,
 }
 
-pub fn sign_ton_personal_message(input: TonSignDataInput, private_key: Vec<u8>) -> Result<String, SignerError> {
-    let private_key = Zeroizing::new(private_key);
-    let payload_str = std::str::from_utf8(&input.payload).map_err(|e| SignerError::new(e.to_string()))?;
-    let parsed = TonSignDataPayload::parse(payload_str)?;
-
-    let signing_key = signing_key_from_bytes(&private_key)?;
-    let signature = signing_key.sign(parsed.data.as_bytes());
-
-    let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
-
-    let payload = serde_json::json!({
-        "type": parsed.payload_type.as_str(),
-        parsed.payload_type.data_field(): parsed.data,
-    });
-
-    let response = TonSignDataResponse {
-        signature: STANDARD.encode(signature.to_bytes()),
-        public_key: STANDARD.encode(signing_key.verifying_key().to_bytes()),
-        timestamp,
-        domain: input.domain,
-        payload,
-    };
+impl TonSignDataResponse {
+    pub fn new(signature: String, public_key: String, timestamp: u64, domain: String, payload: serde_json::Value) -> Self {
+        Self {
+            signature,
+            public_key,
+            timestamp,
+            domain,
+            payload,
+        }
+    }
 
-    Ok(serde_json::to_string(&response)?)
+    pub fn to_json(&self) -> Result<String, SignerError> {
+        serde_json::to_string(self).map_err(SignerError::from)
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ed25519_dalek::Verifier;
-
-    const TEST_PRIVATE_KEY: &str = "1e9d38b5274152a78dff1a86fa464ceadc1f4238ca2c17060c3c507349424a34";
 
     #[test]
     fn test_parse_payload_text() {
@@ -118,46 +101,62 @@ mod tests {
 
         assert_eq!(parsed.payload_type, TonSignDataType::Text);
         assert_eq!(parsed.data, "Hello TON");
+        assert_eq!(parsed.hash(), b"Hello TON".to_vec());
     }
 
     #[test]
-    fn test_verify_signature() {
-        let private_key = hex::decode(TEST_PRIVATE_KEY).unwrap();
-        let text = "Hello TON";
-        let input = TonSignDataInput {
-            domain: "example.com".to_string(),
-            payload: format!(r#"{{"type":"text","text":"{}"}}"#, text).into_bytes(),
-        };
-
-        let result_json = sign_ton_personal_message(input, private_key.clone()).unwrap();
-        let result: serde_json::Value = serde_json::from_str(&result_json).unwrap();
+    fn test_parse_payload_binary() {
+        let json = r#"{"type":"binary","bytes":"SGVsbG8="}"#;
+        let parsed = TonSignDataPayload::parse(json).unwrap();
 
-        let signing_key = signing_key_from_bytes(&private_key).unwrap();
-        let public_key = signing_key.verifying_key();
+        assert_eq!(parsed.payload_type, TonSignDataType::Binary);
+        assert_eq!(parsed.data, "SGVsbG8=");
+    }
 
-        let signature_base64 = result["signature"].as_str().unwrap();
-        let signature_bytes = STANDARD.decode(signature_base64).unwrap();
-        let signature = ed25519_dalek::Signature::from_slice(&signature_bytes).unwrap();
+    #[test]
+    fn test_parse_payload_cell() {
+        let json = r#"{"type":"cell","cell":"te6c"}"#;
+        let parsed = TonSignDataPayload::parse(json).unwrap();
 
-        assert!(public_key.verify(text.as_bytes(), &signature).is_ok());
-        assert_eq!(result["publicKey"].as_str().unwrap(), STANDARD.encode(public_key.to_bytes()));
-        assert!(result["timestamp"].as_u64().unwrap() > 0);
+        assert_eq!(parsed.payload_type, TonSignDataType::Cell);
+        assert_eq!(parsed.data, "te6c");
     }
 
     #[test]
-    fn test_response_format_text() {
-        let private_key = hex::decode(TEST_PRIVATE_KEY).unwrap();
-        let input = TonSignDataInput {
-            domain: "react-app.walletconnect.com".to_string(),
-            payload: r#"{"type":"text","text":"Hello from WalletConnect TON"}"#.as_bytes().to_vec(),
+    fn test_payload_to_json() {
+        let payload = TonSignDataPayload {
+            payload_type: TonSignDataType::Text,
+            data: "Hello TON".to_string(),
         };
 
-        let result_json = sign_ton_personal_message(input, private_key).unwrap();
-        let result: serde_json::Value = serde_json::from_str(&result_json).unwrap();
+        let json = payload.to_json();
+        assert_eq!(json["type"], "text");
+        assert_eq!(json["text"], "Hello TON");
+    }
+
+    #[test]
+    fn test_response_to_json() {
+        let payload = TonSignDataPayload {
+            payload_type: TonSignDataType::Text,
+            data: "Hello TON".to_string(),
+        };
 
-        assert_eq!(result["domain"], "react-app.walletconnect.com");
-        assert!(result["timestamp"].as_u64().unwrap() > 0);
-        assert_eq!(result["payload"]["type"], "text");
-        assert_eq!(result["payload"]["text"], "Hello from WalletConnect TON");
+        let response = TonSignDataResponse::new(
+            "c2lnbmF0dXJl".to_string(),
+            "cHVibGljS2V5".to_string(),
+            1234567890,
+            "example.com".to_string(),
+            payload.to_json(),
+        );
+
+        let json = response.to_json().unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(parsed["signature"], "c2lnbmF0dXJl");
+        assert_eq!(parsed["publicKey"], "cHVibGljS2V5");
+        assert_eq!(parsed["timestamp"], 1234567890);
+        assert_eq!(parsed["domain"], "example.com");
+        assert_eq!(parsed["payload"]["type"], "text");
+        assert_eq!(parsed["payload"]["text"], "Hello TON");
     }
 }

crates/signer/src/ton.rs

@@ -6,7 +6,11 @@ pub struct WalletConnectConfig {
 }
 
 pub fn get_wallet_connect_config() -> WalletConnectConfig {
-    let chains: Vec<Chain> = [vec![Chain::Solana, Chain::Sui, Chain::Ton], EVMChain::all().iter().map(|x| x.to_chain()).collect()].concat();
+    let chains: Vec<Chain> = [
+        vec![Chain::Solana, Chain::Sui, Chain::Ton],
+        EVMChain::all().iter().map(|x| x.to_chain()).collect(),
+    ]
+    .concat();
 
     WalletConnectConfig {
         chains: chains.into_iter().map(|x| x.to_string()).collect(),

gemstone/src/config/wallet_connect.rs

@@ -2,6 +2,7 @@ use alloy_primitives::{eip191_hash_message, hex::encode_prefixed};
 use base64::Engine;
 use base64::engine::general_purpose::STANDARD as BASE64;
 use bs58;
+use signer::{TonSignDataPayload, TonSignDataResponse};
 
 use super::{
     eip712::GemEIP712Message,
@@ -41,19 +42,10 @@ impl SignMessageDecoder {
             }
             SignDigestType::TonPersonal => {
                 let string = String::from_utf8(self.message.data.clone()).map_err(|_| GemstoneError::from("Invalid UTF-8"))?;
-                let Some(json) = serde_json::from_str::<serde_json::Value>(&string).ok() else {
+                let Ok(payload) = TonSignDataPayload::parse(&string) else {
                     return Ok(MessagePreview::Text(string));
                 };
-                let Some(payload_type) = json.get("type").and_then(|v| v.as_str()) else {
-                    return Ok(MessagePreview::Text(string));
-                };
-                let preview = match payload_type {
-                    "text" => json.get("text").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
-                    "binary" => json.get("bytes").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
-                    "cell" => json.get("cell").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
-                    _ => string,
-                };
-                Ok(MessagePreview::Text(preview))
+                Ok(MessagePreview::Text(payload.data))
             }
             SignDigestType::Eip712 => {
                 let string = String::from_utf8(self.message.data.clone()).map_err(|_| GemstoneError::from("Invalid UTF-8 string for EIP712"))?;
@@ -100,7 +92,16 @@ impl SignMessageDecoder {
 
     pub fn hash(&self) -> Vec<u8> {
         match &self.message.sign_type {
-            SignDigestType::SuiPersonal | SignDigestType::TonPersonal => self.message.data.clone(),
+            SignDigestType::SuiPersonal => self.message.data.clone(),
+            SignDigestType::TonPersonal => {
+                let Ok(string) = String::from_utf8(self.message.data.clone()) else {
+                    return Vec::new();
+                };
+                let Ok(payload) = TonSignDataPayload::parse(&string) else {
+                    return Vec::new();
+                };
+                payload.hash()
+            }
             SignDigestType::Eip191 | SignDigestType::Siwe => eip191_hash_message(&self.message.data).to_vec(),
             SignDigestType::Eip712 => match std::str::from_utf8(&self.message.data) {
                 Ok(json) => hash_eip712(json).map(|digest| digest.to_vec()).unwrap_or_default(),
@@ -131,6 +132,15 @@ impl SignMessageDecoder {
             SignDigestType::Base58 => bs58::encode(data).into_string(),
         }
     }
+
+    pub fn get_ton_result(&self, signature: &[u8], public_key: &[u8], timestamp: u64, domain: String) -> Result<String, GemstoneError> {
+        let string = String::from_utf8(self.message.data.clone()).map_err(|_| GemstoneError::from("Invalid UTF-8"))?;
+        let payload = TonSignDataPayload::parse(&string).map_err(|e| GemstoneError::from(e.to_string()))?;
+
+        let response = TonSignDataResponse::new(BASE64.encode(signature), BASE64.encode(public_key), timestamp, domain, payload.to_json());
+
+        response.to_json().map_err(|e| GemstoneError::from(e.to_string()))
+    }
 }
 
 #[cfg(test)]

gemstone/src/message/decoder.rs

@@ -1,5 +1,5 @@
 use gem_ton::address::base64_to_hex_address;
-use signer::{SignatureScheme as GemSignatureScheme, Signer, TonSignDataInput as SignerTonSignDataInput};
+use signer::{SignatureScheme as GemSignatureScheme, Signer};
 
 use crate::GemstoneError;
 
@@ -25,11 +25,6 @@ impl CryptoSigner {
         Signer::sign_digest(scheme, digest, private_key).map_err(GemstoneError::from)
     }
 
-    pub fn sign_ton_personal_message(&self, domain: String, payload: Vec<u8>, private_key: Vec<u8>) -> Result<String, GemstoneError> {
-        let signer_input = SignerTonSignDataInput { domain, payload };
-        Signer::sign_ton_personal_message(signer_input, private_key).map_err(GemstoneError::from)
-    }
-
     pub fn ton_base64_to_raw_address(&self, base64_address: String) -> Result<String, GemstoneError> {
         base64_to_hex_address(base64_address).map_err(|e| GemstoneError::AnyError { msg: e.to_string() })
     }