fix: use tuple enum syntax to make serde work

Author: d4mr

Cargo.toml

@@ -36,8 +36,8 @@ aws-sdk-kms = "1.79.0"
 aws-credential-types = "1.2.4"
 
 # Serialization
-serde = { version = "1.0.219", features = ["derive"] }
-serde_json = "1.0.140"
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.145"
 serde_with = "3.14.0"
 serde-bool = "0.1.3"
 serde_repr = "0.1.20"

core/src/execution_options/solana.rs

@@ -126,7 +126,6 @@ impl CommitmentLevel {
     }
 }
 
-
 #[derive(Serialize, Deserialize, Clone, Debug, utoipa::ToSchema)]
 #[schema(title = "Solana Transaction Options")]
 #[serde(rename_all = "camelCase")]
@@ -141,21 +140,24 @@ pub struct SolanaTransactionOptions {
 
 /// Request to send a Solana transaction
 #[derive(Serialize, Deserialize, Clone, Debug, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
+// #[serde(rename_all = "camelCase")]
 pub struct SendSolanaTransactionRequest {
     /// Idempotency key for this transaction (defaults to random UUID)
     #[serde(default = "super::default_idempotency_key")]
+    #[serde(rename = "idempotencyKey")]
     pub idempotency_key: String,
 
     /// Transaction input (either instructions or serialized transaction)
     #[serde(flatten)]
     pub input: engine_solana_core::transaction::SolanaTransactionInput,
 
     /// Solana execution options
+    #[serde(rename = "executionOptions")]
     pub execution_options: SolanaExecutionOptions,
 
     /// Webhook options for transaction status notifications
     #[serde(default)]
+    #[serde(rename = "webhookOptions")]
     pub webhook_options: Vec<super::WebhookOptions>,
 }
 

executors/src/solana_executor/worker.rs

@@ -601,9 +601,9 @@ impl SolanaExecutorJobHandler {
 
                             // For serialized transactions with existing signatures, we cannot retry with a new blockhash
                             // because the signatures will become invalid. Check if there are any non-default signatures.
-                            if let engine_solana_core::transaction::SolanaTransactionInput::Serialized { transaction } = &job_data.transaction.input {
+                            if let engine_solana_core::transaction::SolanaTransactionInput::Serialized (t) = &job_data.transaction.input {
                                 // Deserialize the base64 transaction to check for signatures
-                                if let Ok(tx_bytes) = base64::engine::general_purpose::STANDARD.decode(transaction)
+                                if let Ok(tx_bytes) = base64::engine::general_purpose::STANDARD.decode(&t.transaction)
                                     && let Ok((versioned_tx, _)) = bincode::serde::decode_from_slice::<solana_sdk::transaction::VersionedTransaction, _>(
                                         &tx_bytes,
                                         bincode::config::standard()
@@ -748,10 +748,10 @@ impl SolanaExecutorJobHandler {
 
         // Build transaction - handle execution options differently for instructions vs serialized
         let versioned_tx = match &job_data.transaction.input {
-            engine_solana_core::transaction::SolanaTransactionInput::Instructions { instructions } => {
+            engine_solana_core::transaction::SolanaTransactionInput::Instructions(i) => {
                 // For instruction-based transactions: calculate priority fees and apply execution options
                 let compute_unit_price = if let Some(priority_fee) = &job_data.transaction.execution_options.priority_fee {
-                    Some(self.get_compute_unit_price(priority_fee, instructions, rpc_client, chain_id_str.as_str()).await?)
+                    Some(self.get_compute_unit_price(priority_fee, &i.instructions, rpc_client, chain_id_str.as_str()).await?)
                 } else {
                     None
                 };
@@ -761,7 +761,7 @@ impl SolanaExecutorJobHandler {
                 let memo_data = format!("thirdweb-engine:{}", transaction_id);
                 let memo_ix = build_memo(&spl_memo_interface::v3::id(), memo_data.as_bytes(), &[]);
 
-                let mut instructions_with_memo = instructions.clone();
+                let mut instructions_with_memo = i.instructions.clone();
                 let memo_data_base64 = base64::engine::general_purpose::STANDARD.encode(memo_data.as_bytes());
                 instructions_with_memo.push(SolanaInstructionData {
                     program_id: memo_ix.program_id,
@@ -771,9 +771,7 @@ impl SolanaExecutorJobHandler {
                 });
 
                 let solana_tx = SolanaTransaction {
-                    input: engine_solana_core::transaction::SolanaTransactionInput::Instructions {
-                        instructions: instructions_with_memo,
-                    },
+                    input: engine_solana_core::transaction::SolanaTransactionInput::new_with_instructions(instructions_with_memo),
                     compute_unit_limit: job_data.transaction.execution_options.compute_unit_limit,
                     compute_unit_price,
                 };

solana-core/src/transaction.rs

@@ -11,16 +11,32 @@ use solana_sdk::{
 
 /// Input for Solana transaction - either build from instructions or use pre-built
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase", untagged)]
+#[serde(untagged)]
 pub enum SolanaTransactionInput {
     /// Build transaction from instructions
-    Instructions {
-        instructions: Vec<SolanaInstructionData>,
-    },
+    Instructions(SolanaTransactionInputInstructions),
     /// Use pre-built serialized VersionedTransaction (base64)
-    Serialized {
-        transaction: String,
-    },
+    Serialized(SolanaTransactionInputSerialized),
+}
+
+impl SolanaTransactionInput {
+    pub fn new_with_instructions(instructions: Vec<SolanaInstructionData>) -> Self {
+        Self::Instructions(SolanaTransactionInputInstructions { instructions })
+    }
+
+    pub fn new_with_serialized(transaction: String) -> Self {
+        Self::Serialized(SolanaTransactionInputSerialized { transaction })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct SolanaTransactionInputInstructions {
+    pub instructions: Vec<SolanaInstructionData>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct SolanaTransactionInputSerialized {
+    pub transaction: String,
 }
 
 /// Solana instruction data provided by the user
@@ -142,11 +158,11 @@ impl SolanaTransaction {
         recent_blockhash: solana_sdk::hash::Hash,
     ) -> Result<VersionedTransaction, SolanaTransactionError> {
         match &self.input {
-            SolanaTransactionInput::Instructions { instructions } => {
-                self.build_from_instructions(instructions, payer, recent_blockhash)
+            SolanaTransactionInput::Instructions(i) => {
+                self.build_from_instructions(&i.instructions, payer, recent_blockhash)
             }
-            SolanaTransactionInput::Serialized { transaction } => {
-                self.deserialize_transaction(transaction, payer)
+            SolanaTransactionInput::Serialized(t) => {
+                self.deserialize_transaction(&t.transaction, payer)
             }
         }
     }
@@ -175,15 +191,12 @@ impl SolanaTransaction {
             inst_list.push(inst.to_instruction()?);
         }
 
-        let message = v0::Message::try_compile(
-            &payer,
-            &inst_list,
-            &[],
-            recent_blockhash,
-        )
-        .map_err(|e| SolanaTransactionError::MessageCompilationFailed {
-            error: e.to_string(),
-        })?;
+        let message =
+            v0::Message::try_compile(&payer, &inst_list, &[], recent_blockhash).map_err(|e| {
+                SolanaTransactionError::MessageCompilationFailed {
+                    error: e.to_string(),
+                }
+            })?;
 
         let message = VersionedMessage::V0(message);
         let num_signatures = message.header().num_required_signatures as usize;
@@ -203,17 +216,19 @@ impl SolanaTransaction {
         tx_base64: &str,
         expected_payer: Pubkey,
     ) -> Result<VersionedTransaction, SolanaTransactionError> {
-        let tx_bytes = Base64Engine.decode(tx_base64)
-            .map_err(|e| SolanaTransactionError::DeserializationFailed {
+        let tx_bytes = Base64Engine.decode(tx_base64).map_err(|e| {
+            SolanaTransactionError::DeserializationFailed {
                 error: format!("Invalid base64: {}", e),
-            })?;
+            }
+        })?;
 
         // Deserialize from binary wire format using bincode
         let (transaction, _): (VersionedTransaction, _) =
-            bincode::serde::decode_from_slice(&tx_bytes, bincode::config::standard())
-                .map_err(|e| SolanaTransactionError::DeserializationFailed {
+            bincode::serde::decode_from_slice(&tx_bytes, bincode::config::standard()).map_err(
+                |e| SolanaTransactionError::DeserializationFailed {
                     error: format!("Failed to deserialize VersionedTransaction: {}", e),
-                })?;
+                },
+            )?;
 
         // Verify fee payer
         let fee_payer = transaction.message.static_account_keys()[0];
@@ -245,10 +260,10 @@ pub enum SolanaTransactionError {
 
     #[error("Invalid blockhash: {error}")]
     InvalidBlockhash { error: String },
-    
+
     #[error("Failed to deserialize transaction: {error}")]
     DeserializationFailed { error: String },
-    
+
     #[error("Fee payer mismatch: expected {expected}, got {got}")]
     FeePayerMismatch { expected: String, got: String },
 }