check message inside tx

Author: 0xh3rman

crates/gem_solana/src/signer/chain_signer.rs

@@ -7,7 +7,7 @@ use solana_primitives::{Pubkey, sign_message as sign_solana_message};
 #[derive(Default)]
 pub struct SolanaChainSigner;
 
-const SIGN_MESSAGE_TRANSACTION_PAYLOAD_ERROR: &str = "Serialized Solana transaction received in signMessage request; use signTransaction instead";
+const SIGN_MESSAGE_PAYLOAD_REJECTION: &str = "Serialized Solana transaction or transaction message received in signMessage request; use signTransaction instead";
 
 impl ChainSigner for SolanaChainSigner {
     fn sign_transfer(&self, input: &SignerInput, private_key: &[u8]) -> Result<String, SignerError> {
@@ -41,7 +41,7 @@ impl ChainSigner for SolanaChainSigner {
 
     fn sign_message(&self, message: &[u8], private_key: &[u8]) -> Result<String, SignerError> {
         if is_transaction_bytes(message) {
-            return Err(SignerError::invalid_input(SIGN_MESSAGE_TRANSACTION_PAYLOAD_ERROR));
+            return Err(SignerError::invalid_input(SIGN_MESSAGE_PAYLOAD_REJECTION));
         }
         let signature = sign_solana_message(private_key, message).map_err(|e| SignerError::signing_error(format!("sign: {e}")))?;
         Ok(bs58::encode(signature.as_bytes()).into_string())
@@ -74,7 +74,7 @@ impl ChainSigner for SolanaChainSigner {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::signer::testkit::{DOUBLE_SIG_TX, EXPECTED_MESSAGE_HEX, SINGLE_SIG_TX};
+    use crate::signer::testkit::{DOUBLE_SIG_TX, EXPECTED_MESSAGE_HEX, SINGLE_SIG_TX, mock_legacy_transaction};
     use gem_encoding::decode_base64;
     use primitives::testkit::signer_mock::TEST_PRIVATE_KEY;
     use primitives::{Chain, ChainSigner, SignerInput, TransactionLoadInput, TransferDataOutputType};
@@ -130,19 +130,34 @@ mod tests {
 
     #[test]
     fn test_sign_message() {
-        let signer = SolanaChainSigner;
-
-        let result = signer.sign_message(b"hello", &TEST_PRIVATE_KEY).unwrap();
+        let result = SolanaChainSigner.sign_message(b"hello", &TEST_PRIVATE_KEY).unwrap();
 
         assert_eq!(bs58::decode(result).into_vec().unwrap().len(), 64);
     }
 
     #[test]
     fn test_sign_message_rejects_transaction_payload() {
-        let signer = SolanaChainSigner;
         let bytes = decode_base64(SINGLE_SIG_TX).unwrap();
-        let result = signer.sign_message(&bytes, &TEST_PRIVATE_KEY);
+        let result = SolanaChainSigner.sign_message(&bytes, &TEST_PRIVATE_KEY);
+
+        assert_eq!(result.unwrap_err().to_string(), format!("Invalid input: {SIGN_MESSAGE_PAYLOAD_REJECTION}"));
+    }
+
+    #[test]
+    fn test_sign_message_rejects_bare_message_payload() {
+        let bytes = decode_base64(SINGLE_SIG_TX).unwrap();
+        let transaction = VersionedTransaction::deserialize_with_version(&bytes).unwrap();
+        let message = transaction.serialize_message().unwrap();
+        let result = SolanaChainSigner.sign_message(&message, &TEST_PRIVATE_KEY);
+
+        assert_eq!(result.unwrap_err().to_string(), format!("Invalid input: {SIGN_MESSAGE_PAYLOAD_REJECTION}"));
+    }
+
+    #[test]
+    fn test_sign_message_rejects_legacy_bare_message_payload() {
+        let message = mock_legacy_transaction().serialize_message().unwrap();
+        let result = SolanaChainSigner.sign_message(&message, &TEST_PRIVATE_KEY);
 
-        assert_eq!(result.unwrap_err().to_string(), format!("Invalid input: {SIGN_MESSAGE_TRANSACTION_PAYLOAD_ERROR}"));
+        assert_eq!(result.unwrap_err().to_string(), format!("Invalid input: {SIGN_MESSAGE_PAYLOAD_REJECTION}"));
     }
 }

crates/gem_solana/src/signer/testkit.rs

@@ -1,7 +1,7 @@
 use gem_encoding::decode_base64;
 use primitives::testkit::signer_mock::TEST_PRIVATE_KEY;
 use primitives::{SolanaTokenProgramId, TransactionLoadMetadata};
-use solana_primitives::{Pubkey, VersionedTransaction, get_address};
+use solana_primitives::{CompiledInstruction, LegacyMessage, MessageHeader, Pubkey, VersionedTransaction, get_address};
 
 pub const TEST_RECIPIENT: &str = "EN2sCsJ1WDV8UFqsiTXHcUPUxQ4juE71eCknHYYMifkd";
 pub const TEST_SENDER_TOKEN_ADDRESS: &str = "HEeranxp3y7kVQKVSLdZW1rUmnbs7bAtUTMu8o88Jash";
@@ -26,6 +26,26 @@ pub fn base58_transaction(encoded_base64: &str) -> String {
     bs58::encode(decode_base64(encoded_base64).unwrap()).into_string()
 }
 
+pub fn mock_legacy_transaction() -> VersionedTransaction {
+    VersionedTransaction::Legacy {
+        signatures: vec![],
+        message: LegacyMessage {
+            header: MessageHeader {
+                num_required_signatures: 1,
+                num_readonly_signed_accounts: 0,
+                num_readonly_unsigned_accounts: 1,
+            },
+            account_keys: vec![Pubkey::new([1; 32]), Pubkey::new([2; 32])],
+            recent_blockhash: [3; 32],
+            instructions: vec![CompiledInstruction {
+                program_id_index: 1,
+                accounts: vec![0],
+                data: vec![],
+            }],
+        },
+    }
+}
+
 pub fn program_id(transaction: &VersionedTransaction, index: usize) -> String {
     let instruction = &transaction.instructions()[index];
     transaction.account_keys()[instruction.program_id_index as usize].to_base58()

crates/gem_solana/src/transaction.rs

@@ -14,7 +14,16 @@ pub fn try_decode_transaction_bytes(transaction: &[u8]) -> Option<VersionedTrans
 }
 
 pub fn is_transaction_bytes(transaction: &[u8]) -> bool {
-    try_decode_transaction_bytes(transaction).is_some()
+    try_decode_transaction_bytes(transaction).is_some() || try_decode_transaction_message(transaction).is_some()
+}
+
+fn try_decode_transaction_message(message: &[u8]) -> Option<VersionedTransaction> {
+    let mut transaction = Vec::with_capacity(message.len() + 1);
+    transaction.push(0);
+    transaction.extend_from_slice(message);
+
+    let decoded = VersionedTransaction::deserialize_with_version(&transaction).ok()?;
+    (decoded.serialize_message().ok()? == message).then_some(decoded)
 }
 
 pub fn decode_transaction(transaction_base64: &str) -> Result<VersionedTransaction, String> {
@@ -60,7 +69,7 @@ pub fn instructions_from_primitives(instructions: Vec<SolanaInstruction>) -> Res
 mod tests {
     use super::*;
     #[cfg(feature = "signer")]
-    use crate::signer::testkit::SINGLE_SIG_TX;
+    use crate::signer::testkit::{SINGLE_SIG_TX, mock_legacy_transaction};
 
     #[test]
     fn test_try_decode_blockhash() {
@@ -72,11 +81,19 @@ mod tests {
     #[cfg(feature = "signer")]
     #[test]
     fn test_is_transaction_bytes() {
-        let mut bytes = gem_encoding::decode_base64(SINGLE_SIG_TX).unwrap();
-        assert!(is_transaction_bytes(&bytes));
+        let full_transaction = gem_encoding::decode_base64(SINGLE_SIG_TX).unwrap();
+        let transaction = VersionedTransaction::deserialize_with_version(&full_transaction).unwrap();
+        let mut v0_message = transaction.serialize_message().unwrap();
+        let mut transaction_with_trailing_byte = full_transaction.clone();
+
+        assert!(is_transaction_bytes(&full_transaction));
+        assert!(is_transaction_bytes(&v0_message));
+        assert!(is_transaction_bytes(&mock_legacy_transaction().serialize_message().unwrap()));
 
-        bytes.push(0);
-        assert!(!is_transaction_bytes(&bytes));
+        transaction_with_trailing_byte.push(0);
+        v0_message.push(0);
+        assert!(!is_transaction_bytes(&transaction_with_trailing_byte));
+        assert!(!is_transaction_bytes(&v0_message));
         assert!(!is_transaction_bytes(b"hello"));
     }
 }