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);
}
}