src/wallets/signature.rs

// function to sign messages and return hex
pub fn sign_transaction(message: &str, private_key_hex: &str) -> String {

    let secp = Secp256k1::new();

    // Decode the private key from hex
    let private_key_bytes = hex::decode(private_key_hex)
        .expect("Failed to decode private key hex");
    let private_key = SecretKey::from_slice(&private_key_bytes)
        .expect("Failed to create SecretKey from hex");

    // Create a message hash
    let message_bytes = hex::decode(message)
        .expect("Failed to decode message hex");
    let message_hash = Message::from_slice(&message_bytes)
        .expect("Failed to create message hash");

    // Sign the message
    let signature = secp.sign(&message_hash, &private_key);

    hex::encode(signature.serialize_compact())
}

src/wallets/verifications.rs

// decode the address to strip prefix. This will convert address back to it public signature
pub fn decode_address(address: &str) -> Result<String, &'static str> {
    let public_key_hex = &address[3..];

    let public_key_xor_bytes = hex::decode(public_key_hex).map_err(|_| "Failed to decode hex")?;
    // Define a custom XOR key based on the length of the XORed public key
    let xor_key: Vec<u8> = vec![0x01; public_key_xor_bytes.len()];

    let original_public_key_bytes: Vec<u8> = public_key_xor_bytes
        .iter()
        .zip(xor_key.iter())
        .map(|(a, b)| a ^ b)
        .collect();

    // Convert the original public key bytes to hex
    let original_public_key_hex: String = original_public_key_bytes
        .iter()
        .map(|&byte| format!("{:02x}", byte))
        .collect();
    Ok(original_public_key_hex)
}

src/wallets/verifications.rs

// message must be included, signed hex of the message must be included, address with must be included
pub fn verify_transaction(message: &str, signature_hex: &str, address: &str) -> bool {
    let secp = Secp256k1::new();
    if hex::decode(message).is_ok() {
        match decode_address(address) {
            Ok(public_key_hex) => {
                // Decode the public key from hex
                let public_key_bytes = hex::decode(&public_key_hex).expect("Failed to decode public key hex");
                match PublicKey::from_slice(&public_key_bytes) {
                    Ok(public_key) => {
                        // Create a message hash
                        let message_bytes = hex::decode(message).expect("Failed to decode message hex");
                        let message_hash = Message::from_slice(&message_bytes).expect("Failed to create message hash");

                        // Decode the signature from hex
                        let signature_bytes = hex::decode(signature_hex).expect("Failed to decode signature hex");
                        let signature = Signature::from_compact(&signature_bytes).expect("Failed to create Signature from hex");

                        // Verify the signature
                        if secp.verify(&message_hash, &signature, &public_key).is_ok() {
                            true
                        } else {
                            println!("Signature verification failed!");
                            false
                        }
                    }
                    Err(_) => {
                        println!("Failed to create PublicKey from bytes");
                        false
                    }
                }
            }
            Err(_) => {
                println!("Failed to decode public key hex");
                false
            }
        }
    } else {
        // If the message is not a valid hex string, treat it as plain text and check the signature

        // Decode the public key from hex
        let public_key_bytes = hex::decode(address).expect("Failed to decode public key hex");
        match PublicKey::from_slice(&public_key_bytes) {
            Ok(public_key) => {
                // Convert the message to bytes
                let message_bytes = message.as_bytes();

                // Create a message hash
                let message_hash = Message::from_slice(&message_bytes).expect("Failed to create message hash");

                // Decode the signature from hex
                let signature_bytes = hex::decode(signature_hex).expect("Failed to decode signature hex");
                let signature = Signature::from_compact(&signature_bytes).expect("Failed to create Signature from hex");

                // Verify the signature
                if secp.verify(&message_hash, &signature, &public_key).is_ok() {
                    true
                } else {
                    println!("Signature verification failed!");
                    false
                }
            }
            Err(_) => {
                println!("Failed to create PublicKey from bytes");
                false
            }
        }
    }
}