feat(rpc/v06): adjust return type serialization for `starknet_getTran…

…sactionStatus`
eqlabs · Jan 31, 2025 · 91cb4ba · 91cb4ba
1 parent bd53fba
commit 91cb4ba
Show file tree

Hide file tree

Showing 2 changed files with 142 additions and 7 deletions.
diff --git a/crates/rpc/src/method/get_transaction_status.rs b/crates/rpc/src/method/get_transaction_status.rs
@@ -165,14 +165,111 @@ impl crate::dto::SerializeForVersion for Output {
         &self,
         serializer: crate::dto::Serializer,
     ) -> Result<crate::dto::Ok, crate::dto::Error> {
-        let mut serializer = serializer.serialize_struct()?;
-        serializer.serialize_field("finality_status", &self.finality_status())?;
-        serializer.serialize_optional("execution_status", self.execution_status())?;
-        // Delete check once rustc gives you a friendly reminder
-        if serializer.version != RpcVersion::V07 {
-            serializer.serialize_optional("failure_reason", self.failure_reason())?;
+        if serializer.version == RpcVersion::V06 {
+            let v06_output = v06::GetTransactionStatusOutput::from(self);
+            return v06_output.serialize(serializer);
+        } else {
+            let mut serializer = serializer.serialize_struct()?;
+            serializer.serialize_field("finality_status", &self.finality_status())?;
+            serializer.serialize_optional("execution_status", self.execution_status())?;
+            // Delete check once rustc gives you a friendly reminder
+            if serializer.version != RpcVersion::V07 {
+                serializer.serialize_optional("failure_reason", self.failure_reason())?;
+            }
+            serializer.end()
+        }
+    }
+}
+
+mod v06 {
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub struct GetTransactionStatusOutput {
+        pub finality_status: FinalityStatus,
+        pub execution_status: Option<ExecutionStatus>,
+    }
+
+    impl crate::dto::SerializeForVersion for GetTransactionStatusOutput {
+        fn serialize(
+            &self,
+            serializer: crate::dto::Serializer,
+        ) -> Result<crate::dto::Ok, crate::dto::Error> {
+            let mut s = serializer.serialize_struct()?;
+            s.serialize_field("finality_status", &self.finality_status)?;
+            if let Some(execution_status) = &self.execution_status {
+                s.serialize_field("execution_status", execution_status)?;
+            }
+            s.end()
+        }
+    }
+
+    impl From<&super::Output> for GetTransactionStatusOutput {
+        fn from(output: &super::Output) -> Self {
+            match output {
+                super::Output::Received => Self {
+                    finality_status: FinalityStatus::Received,
+                    execution_status: None,
+                },
+                super::Output::Rejected { .. } => Self {
+                    finality_status: FinalityStatus::Rejected,
+                    execution_status: None,
+                },
+                super::Output::AcceptedOnL1(status) => Self {
+                    finality_status: FinalityStatus::AcceptedOnL1,
+                    execution_status: Some(match status {
+                        super::TxnExecutionStatus::Succeeded => ExecutionStatus::Succeeded,
+                        super::TxnExecutionStatus::Reverted { .. } => ExecutionStatus::Reverted,
+                    }),
+                },
+                super::Output::AcceptedOnL2(status) => Self {
+                    finality_status: FinalityStatus::AcceptedOnL2,
+                    execution_status: Some(match status {
+                        super::TxnExecutionStatus::Succeeded => ExecutionStatus::Succeeded,
+                        super::TxnExecutionStatus::Reverted { .. } => ExecutionStatus::Reverted,
+                    }),
+                },
+            }
+        }
+    }
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub enum FinalityStatus {
+        Received,
+        Rejected,
+        AcceptedOnL1,
+        AcceptedOnL2,
+    }
+
+    impl crate::dto::SerializeForVersion for FinalityStatus {
+        fn serialize(
+            &self,
+            serializer: crate::dto::Serializer,
+        ) -> Result<crate::dto::Ok, crate::dto::Error> {
+            serializer.serialize_str(match self {
+                FinalityStatus::Received => "RECEIVED",
+                FinalityStatus::Rejected => "REJECTED",
+                FinalityStatus::AcceptedOnL1 => "ACCEPTED_ON_L1",
+                FinalityStatus::AcceptedOnL2 => "ACCEPTED_ON_L2",
+            })
+        }
+    }
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub enum ExecutionStatus {
+        Succeeded,
+        Reverted,
+    }
+
+    impl crate::dto::SerializeForVersion for ExecutionStatus {
+        fn serialize(
+            &self,
+            serializer: crate::dto::Serializer,
+        ) -> Result<crate::dto::Ok, crate::dto::Error> {
+            serializer.serialize_str(match self {
+                ExecutionStatus::Succeeded => "SUCCEEDED",
+                ExecutionStatus::Reverted => "REVERTED",
+            })
         }
-        serializer.end()
     }
 }
 
@@ -315,4 +412,41 @@ mod tests {
 
         assert_matches!(err, Error::TxnHashNotFound);
     }
+
+    #[test]
+    fn test_v06_serialization() {
+        use crate::dto::SerializeForVersion;
+
+        let cases = [
+            (Output::Received, json!({"finality_status": "RECEIVED"})),
+            (
+                Output::Rejected {
+                    error_message: Some("error".to_string()),
+                },
+                json!({"finality_status": "REJECTED"}),
+            ),
+            (
+                Output::AcceptedOnL1(TxnExecutionStatus::Succeeded),
+                json!({
+                    "finality_status": "ACCEPTED_ON_L1",
+                    "execution_status": "SUCCEEDED"
+                }),
+            ),
+            (
+                Output::AcceptedOnL2(TxnExecutionStatus::Reverted {
+                    reason: Some("error".to_string()),
+                }),
+                json!({
+                    "finality_status": "ACCEPTED_ON_L2",
+                    "execution_status": "REVERTED"
+                }),
+            ),
+        ];
+
+        for (output, expected) in cases {
+            let serializer = crate::dto::Serializer::new(crate::RpcVersion::V06);
+            let encoded = output.serialize(serializer).unwrap();
+            assert_eq!(encoded, expected);
+        }
+    }
 }
diff --git a/crates/rpc/src/v06.rs b/crates/rpc/src/v06.rs
@@ -10,4 +10,5 @@ pub fn register_routes() -> RpcRouterBuilder {
         .register("starknet_getStorageAt",                        crate::method::get_storage_at)
         .register("starknet_call",                                crate::method::call)
         .register("starknet_getEstimateFee",                      crate::method::estimate_fee)
+        .register("starknet_getTransactionStatus",                crate::method::get_transaction_status)
 }