RPC: Support base64 encoded transactions

Defaults to base58

client/src/rpc_client.rs

@@ -5,7 +5,8 @@ use crate::{
     rpc_config::RpcAccountInfoConfig,
     rpc_config::{
         RpcGetConfirmedSignaturesForAddress2Config, RpcLargestAccountsConfig,
-        RpcProgramAccountsConfig, RpcSendTransactionConfig, RpcTokenAccountsFilter,
+        RpcProgramAccountsConfig, RpcSendTransactionConfig, RpcSimulateTransactionConfig,
+        RpcTokenAccountsFilter,
     },
     rpc_request::{RpcError, RpcRequest, TokenAccountsFilter},
     rpc_response::*,
@@ -48,6 +49,26 @@ pub struct RpcClient {
     sender: Box<dyn RpcSender + Send + Sync + 'static>,
 }
 
+fn serialize_encode_transaction(
+    transaction: &Transaction,
+    encoding: UiTransactionEncoding,
+) -> ClientResult<String> {
+    let serialized = serialize(transaction)
+        .map_err(|e| ClientErrorKind::Custom(format!("transaction serialization failed: {}", e)))?;
+    let encoded = match encoding {
+        UiTransactionEncoding::Base58 => bs58::encode(serialized).into_string(),
+        UiTransactionEncoding::Base64 => base64::encode(serialized),
+        _ => {
+            return Err(ClientErrorKind::Custom(format!(
+                "unsupported transaction encoding: {}. Supported encodings: base58, base64",
+                encoding
+            ))
+            .into())
+        }
+    };
+    Ok(encoded)
+}
+
 impl RpcClient {
     pub fn new_sender<T: RpcSender + Send + Sync + 'static>(sender: T) -> Self {
         Self {
@@ -112,8 +133,8 @@ impl RpcClient {
         transaction: &Transaction,
         config: RpcSendTransactionConfig,
     ) -> ClientResult<Signature> {
-        let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
-
+        let encoding = config.encoding.unwrap_or(UiTransactionEncoding::Base58);
+        let serialized_encoded = serialize_encode_transaction(transaction, encoding)?;
         let signature_base58_str: String = self.send(
             RpcRequest::SendTransaction,
             json!([serialized_encoded, config]),
@@ -142,7 +163,21 @@ impl RpcClient {
         transaction: &Transaction,
         sig_verify: bool,
     ) -> RpcResult<RpcSimulateTransactionResult> {
-        let serialized_encoded = bs58::encode(serialize(transaction).unwrap()).into_string();
+        self.simulate_transaction_with_config(
+            transaction,
+            sig_verify,
+            RpcSimulateTransactionConfig::default(),
+        )
+    }
+
+    pub fn simulate_transaction_with_config(
+        &self,
+        transaction: &Transaction,
+        sig_verify: bool,
+        config: RpcSimulateTransactionConfig,
+    ) -> RpcResult<RpcSimulateTransactionResult> {
+        let encoding = config.encoding.unwrap_or(UiTransactionEncoding::Base58);
+        let serialized_encoded = serialize_encode_transaction(transaction, encoding)?;
         self.send(
             RpcRequest::SimulateTransaction,
             json!([serialized_encoded, { "sigVerify": sig_verify }]),

client/src/rpc_config.rs

@@ -4,6 +4,7 @@ use solana_sdk::{
     clock::Epoch,
     commitment_config::{CommitmentConfig, CommitmentLevel},
 };
+use solana_transaction_status::UiTransactionEncoding;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -17,6 +18,7 @@ pub struct RpcSendTransactionConfig {
     #[serde(default)]
     pub skip_preflight: bool,
     pub preflight_commitment: Option<CommitmentLevel>,
+    pub encoding: Option<UiTransactionEncoding>,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
@@ -26,6 +28,7 @@ pub struct RpcSimulateTransactionConfig {
     pub sig_verify: bool,
     #[serde(flatten)]
     pub commitment: Option<CommitmentConfig>,
+    pub encoding: Option<UiTransactionEncoding>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]