Merge pull request #1310 from eqlabs/krisztian/json-rpc-0.4.0

feat(rpc): add support for final JSON-RPC 0.4.0 specification

CHANGELOG.md

@@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - RPC v0.4 `starknet_getTransactionReceipt` incorrect execution and finality status names
 - `pathfinder_getTransactionStatus` fails to parse v0.12.1 gateway replies
 
+### Changed
+
+- RPC v0.4.0 support (previously supported v0.4.0-rc3)
+
 ## [0.7.0] - 2023-07-27
 
 ### Added

crates/rpc/src/cairo/ext_py.rs

@@ -19,7 +19,9 @@ use crate::v02::types::reply::FeeEstimate;
 use crate::v02::types::request::{
     BroadcastedDeclareTransaction, BroadcastedInvokeTransaction, BroadcastedTransaction, Call,
 };
-use pathfinder_common::{BlockTimestamp, CallResultValue, ClassHash, EthereumAddress, StateUpdate};
+use pathfinder_common::{
+    BlockTimestamp, CallResultValue, ClassHash, EthereumAddress, StateUpdate, TransactionNonce,
+};
 use starknet_gateway_types::request::add_transaction;
 use std::sync::Arc;
 use tokio::sync::{mpsc, oneshot, Mutex};
@@ -223,6 +225,33 @@ fn map_tx(tx: BroadcastedTransaction) -> Result<TransactionAndClassHashHint, Cal
             ),
             class_hash_hint: None,
         },
+        BroadcastedTransaction::Declare(BroadcastedDeclareTransaction::V0(tx)) => {
+            let class_hash = tx
+                .contract_class
+                .class_hash()
+                .map_err(|_| CallFailure::Internal("Failed to calculate class hash"))?;
+            use starknet_gateway_types::class_hash::ComputedClassHash;
+            let class_hash = match class_hash {
+                ComputedClassHash::Cairo(c) => ClassHash(c.0),
+                ComputedClassHash::Sierra(s) => ClassHash(s.0),
+            };
+            TransactionAndClassHashHint {
+                transaction: add_transaction::AddTransaction::Declare(add_transaction::Declare {
+                    version: tx.version,
+                    max_fee: tx.max_fee,
+                    signature: tx.signature,
+                    contract_class: add_transaction::ContractDefinition::Cairo(
+                        tx.contract_class.try_into().map_err(|_| {
+                            CallFailure::Internal("contract class serialization failure")
+                        })?,
+                    ),
+                    sender_address: tx.sender_address,
+                    nonce: TransactionNonce::ZERO,
+                    compiled_class_hash: None,
+                }),
+                class_hash_hint: Some(class_hash),
+            }
+        }
         BroadcastedTransaction::Declare(BroadcastedDeclareTransaction::V1(tx)) => {
             let class_hash = tx
                 .contract_class

crates/rpc/src/v02/method/add_declare_transaction.rs

@@ -78,6 +78,11 @@ pub async fn add_declare_transaction(
     input: AddDeclareTransactionInput,
 ) -> Result<AddDeclareTransactionOutput, AddDeclareTransactionError> {
     match input.declare_transaction {
+        Transaction::Declare(BroadcastedDeclareTransaction::V0(_)) => {
+            Err(AddDeclareTransactionError::Internal(anyhow::anyhow!(
+                "Declare v0 transactions are not allowed"
+            )))
+        }
         Transaction::Declare(BroadcastedDeclareTransaction::V1(tx)) => {
             let contract_definition: CairoContractDefinition = tx
                 .contract_class

crates/rpc/src/v02/types.rs

@@ -61,6 +61,7 @@ pub mod request {
         serde(untagged)
     )]
     pub enum BroadcastedDeclareTransaction {
+        V0(BroadcastedDeclareTransactionV0),
         V1(BroadcastedDeclareTransactionV1),
         V2(BroadcastedDeclareTransactionV2),
     }
@@ -82,17 +83,37 @@ pub mod request {
             let v = serde_json::Value::deserialize(deserializer)?;
             let version = Version::deserialize(&v).map_err(de::Error::custom)?;
             match version.version.without_query_version() {
+                0 => Ok(Self::V0(
+                    BroadcastedDeclareTransactionV0::deserialize(&v).map_err(de::Error::custom)?,
+                )),
                 1 => Ok(Self::V1(
                     BroadcastedDeclareTransactionV1::deserialize(&v).map_err(de::Error::custom)?,
                 )),
                 2 => Ok(Self::V2(
                     BroadcastedDeclareTransactionV2::deserialize(&v).map_err(de::Error::custom)?,
                 )),
-                _v => Err(de::Error::custom("version must be 1 or 2")),
+                _v => Err(de::Error::custom("version must be 0, 1 or 2")),
             }
         }
     }
 
+    #[serde_as]
+    #[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
+    #[cfg_attr(any(test, feature = "rpc-full-serde"), derive(serde::Serialize))]
+    #[serde(deny_unknown_fields)]
+    pub struct BroadcastedDeclareTransactionV0 {
+        // BROADCASTED_TXN_COMMON_PROPERTIES: ideally this should just be included
+        // here in a flattened struct, but `flatten` doesn't work with
+        // `deny_unknown_fields`: https://serde.rs/attr-flatten.html#struct-flattening
+        pub max_fee: Fee,
+        #[serde_as(as = "TransactionVersionAsHexStr")]
+        pub version: TransactionVersion,
+        pub signature: Vec<TransactionSignatureElem>,
+
+        pub contract_class: super::CairoContractClass,
+        pub sender_address: ContractAddress,
+    }
+
     #[serde_as]
     #[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
     #[cfg_attr(any(test, feature = "rpc-full-serde"), derive(serde::Serialize))]

crates/rpc/src/v03/method/estimate_fee.rs

@@ -147,8 +147,9 @@ pub(crate) mod tests {
         use super::*;
 
         use crate::v02::types::request::{
-            BroadcastedDeclareTransaction, BroadcastedDeclareTransactionV1,
-            BroadcastedDeclareTransactionV2, BroadcastedInvokeTransactionV1,
+            BroadcastedDeclareTransaction, BroadcastedDeclareTransactionV0,
+            BroadcastedDeclareTransactionV1, BroadcastedDeclareTransactionV2,
+            BroadcastedInvokeTransactionV1,
         };
         use crate::v02::types::{ContractClass, SierraContractClass};
 
@@ -445,6 +446,37 @@ pub(crate) mod tests {
             assert_eq!(result, vec![FeeEstimate::default(), FeeEstimate::default()]);
         }
 
+        #[test_log::test(tokio::test)]
+        async fn successful_declare_v0() {
+            let (_db_dir, context, _join_handle, _account_address, latest_block_hash) =
+                test_context_with_call_handling().await;
+
+            let contract_class = {
+                let json = starknet_gateway_test_fixtures::class_definitions::CONTRACT_DEFINITION;
+                ContractClass::from_definition_bytes(json)
+                    .unwrap()
+                    .as_cairo()
+                    .unwrap()
+            };
+
+            let declare_transaction = BroadcastedTransaction::Declare(
+                BroadcastedDeclareTransaction::V0(BroadcastedDeclareTransactionV0 {
+                    version: TransactionVersion::ZERO_WITH_QUERY_VERSION,
+                    max_fee: Fee::default(),
+                    signature: vec![],
+                    contract_class,
+                    sender_address: contract_address!("0x1"),
+                }),
+            );
+
+            let input = EstimateFeeInput {
+                request: vec![declare_transaction],
+                block_id: BlockId::Hash(latest_block_hash),
+            };
+            let result = estimate_fee(context, input).await.unwrap();
+            assert_eq!(result, vec![FeeEstimate::default()]);
+        }
+
         #[test_log::test(tokio::test)]
         async fn successful_declare_v1() {
             let (_db_dir, context, _join_handle, account_address, latest_block_hash) =

crates/rpc/src/v04/method/add_declare_transaction.rs

@@ -143,6 +143,9 @@ pub async fn add_declare_transaction(
     input: AddDeclareTransactionInput,
 ) -> Result<AddDeclareTransactionOutput, AddDeclareTransactionError> {
     match input.declare_transaction {
+        Transaction::Declare(BroadcastedDeclareTransaction::V0(_)) => {
+            Err(AddDeclareTransactionError::UnsupportedTransactionVersion)
+        }
         Transaction::Declare(BroadcastedDeclareTransaction::V1(tx)) => {
             let contract_definition: CairoContractDefinition = tx
                 .contract_class