quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
use base64::{engine::general_purpose, Engine as _};
use solana_sdk::transaction::{Transaction, VersionedTransaction};

use crate::QuorumError;

pub trait QuorumSerializableTransaction {
    fn to_wire_base64(&self) -> Result<String, QuorumError>;
}

impl QuorumSerializableTransaction for Transaction {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        let bytes =
            bincode::serialize(self).map_err(|e| QuorumError::Serialization(e.to_string()))?;
        Ok(general_purpose::STANDARD.encode(bytes))
    }
}

impl QuorumSerializableTransaction for VersionedTransaction {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        let bytes =
            bincode::serialize(self).map_err(|e| QuorumError::Serialization(e.to_string()))?;
        Ok(general_purpose::STANDARD.encode(bytes))
    }
}

impl QuorumSerializableTransaction for str {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        if self.is_empty() {
            return Err(QuorumError::Serialization(
                "base64 wire transaction string is empty".into(),
            ));
        }
        general_purpose::STANDARD
            .decode(self)
            .map_err(|e| QuorumError::Serialization(format!("invalid base64: {e}")))?;
        Ok(self.to_owned())
    }
}

impl QuorumSerializableTransaction for String {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        self.as_str().to_wire_base64()
    }
}

impl QuorumSerializableTransaction for [u8] {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        if self.is_empty() {
            return Err(QuorumError::Serialization(
                "wire transaction byte slice is empty".into(),
            ));
        }
        Ok(general_purpose::STANDARD.encode(self))
    }
}

impl QuorumSerializableTransaction for Vec<u8> {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        self.as_slice().to_wire_base64()
    }
}

impl<T: QuorumSerializableTransaction + ?Sized> QuorumSerializableTransaction for &T {
    fn to_wire_base64(&self) -> Result<String, QuorumError> {
        T::to_wire_base64(self)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use solana_sdk::{
        hash::Hash,
        signature::Keypair,
        signer::Signer,
        transaction::Transaction,
    };

    #[allow(deprecated)]
    fn dummy_signed_tx() -> Transaction {
        use solana_sdk::system_instruction;
        let payer = Keypair::new();
        let recipient = Keypair::new().pubkey();
        let ix = system_instruction::transfer(&payer.pubkey(), &recipient, 1_000);
        Transaction::new_signed_with_payer(
            &[ix],
            Some(&payer.pubkey()),
            &[&payer],
            Hash::default(),
        )
    }

    #[test]
    fn legacy_tx_round_trips() {
        let tx = dummy_signed_tx();
        let b64 = tx.to_wire_base64().expect("serialization failed");
        assert!(!b64.is_empty());
        let raw = general_purpose::STANDARD.decode(&b64).unwrap();
        let decoded: Transaction = bincode::deserialize(&raw).unwrap();
        assert_eq!(tx.signatures, decoded.signatures);
    }

    #[test]
    fn str_passthrough_valid() {
        let tx = dummy_signed_tx();
        let b64 = tx.to_wire_base64().unwrap();
        let again = b64.as_str().to_wire_base64().unwrap();
        assert_eq!(b64, again);
    }

    #[test]
    fn str_passthrough_rejects_invalid_base64() {
        let err = "NOT!!VALID%%BASE64".to_wire_base64();
        assert!(err.is_err());
    }

    #[test]
    fn empty_str_is_err() {
        let err = "".to_wire_base64();
        assert!(matches!(err, Err(QuorumError::Serialization(_))));
    }

    #[test]
    fn raw_bytes_encodes() {
        let bytes: Vec<u8> = vec![0xDE, 0xAD, 0xBE, 0xEF];
        let b64 = bytes.to_wire_base64().unwrap();
        let decoded = general_purpose::STANDARD.decode(&b64).unwrap();
        assert_eq!(decoded, bytes);
    }
}