get_class/get_class_at implemented

Cargo.toml

@@ -28,7 +28,7 @@ tower-http = { version = "0.4", features = ["full"] }
 tower = { version = "0.4", features = ["full"] }
 
 # rpc
-rpc-core = { git = "https://github.com/foundry-rs/foundry.git", package = "anvil-rpc" }
+rpc-core = { git = "https://github.com/foundry-rs/foundry", rev = "5f2262736feaeabadeef2ae989a78e9b43da8eee", package = "anvil-rpc" }
 
 # async
 tokio = { version = "1", features = ["time", "macros", "rt-multi-thread"] }

crates/starknet-server/src/api/json_rpc/endpoints.rs

@@ -3,6 +3,7 @@ use starknet_in_rust::core::errors::state_errors::StateError;
 use starknet_in_rust::definitions::block_context::StarknetChainId;
 use starknet_in_rust::transaction::error::TransactionError;
 use starknet_in_rust::utils::Address;
+use starknet_rs_core::types::ContractClass as CodegenContractClass;
 use starknet_types::contract_address::ContractAddress;
 use starknet_types::felt::{ClassHash, Felt, TransactionHash};
 use starknet_types::starknet_api::block::BlockNumber;
@@ -16,7 +17,6 @@ use super::write_endpoints::{
 };
 use super::{JsonRpcHandler, RpcResult};
 use crate::api::models::block::{Block, BlockHeader};
-use crate::api::models::contract_class::ContractClass;
 use crate::api::models::state::{
     ClassHashes, ContractNonce, DeployedContract, StateUpdate, StorageDiff, StorageEntry,
     ThinStateDiff,
@@ -196,10 +196,37 @@ impl JsonRpcHandler {
     /// starknet_getClass
     pub(crate) async fn get_class(
         &self,
-        _block_id: BlockId,
-        _class_hash: ClassHash,
-    ) -> RpcResult<ContractClass> {
-        Err(error::ApiError::ClassHashNotFound)
+        block_id: BlockId,
+        class_hash: ClassHash,
+    ) -> RpcResult<CodegenContractClass> {
+        match self.api.starknet.read().await.get_class(block_id.into(), class_hash) {
+            Ok(contract_class) => Ok(contract_class.try_into()?),
+            Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
+            Err(
+                Error::ContractNotFound
+                | Error::StateError(StateError::NoneContractState(_))
+                | Error::NoStateAtBlock { block_number: _ },
+            ) => Err(ApiError::ContractNotFound),
+            Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
+        }
+    }
+
+    /// starknet_getClassAt
+    pub(crate) async fn get_class_at(
+        &self,
+        block_id: BlockId,
+        contract_address: ContractAddress,
+    ) -> RpcResult<CodegenContractClass> {
+        match self.api.starknet.read().await.get_class_at(block_id.into(), contract_address) {
+            Ok(contract_class) => Ok(contract_class.try_into()?),
+            Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
+            Err(
+                Error::ContractNotFound
+                | Error::StateError(StateError::NoneContractState(_))
+                | Error::NoStateAtBlock { block_number: _ },
+            ) => Err(ApiError::ContractNotFound),
+            Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
+        }
     }
 
     /// starknet_getClassHashAt
@@ -208,26 +235,18 @@ impl JsonRpcHandler {
         block_id: BlockId,
         contract_address: ContractAddress,
     ) -> RpcResult<ClassHash> {
-        let starknet = self.api.starknet.read().await;
-        match starknet.get_class_hash_at(&block_id.into(), &contract_address) {
+        match self.api.starknet.read().await.get_class_hash_at(block_id.into(), contract_address) {
             Ok(class_hash) => Ok(class_hash),
             Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
-            Err(Error::ContractNotFound | Error::NoStateAtBlock { block_number: _ }) => {
-                Err(ApiError::ContractNotFound)
-            }
+            Err(
+                Error::ContractNotFound
+                | Error::StateError(StateError::NoneContractState(_))
+                | Error::NoStateAtBlock { block_number: _ },
+            ) => Err(ApiError::ContractNotFound),
             Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
         }
     }
 
-    /// starknet_getClassAt
-    pub(crate) async fn get_class_at(
-        &self,
-        _block_id: BlockId,
-        _contract_address: ContractAddress,
-    ) -> RpcResult<ContractClass> {
-        Err(error::ApiError::ContractNotFound)
-    }
-
     /// starknet_getBlockTransactionCount
     pub(crate) async fn get_block_txs_count(&self, block_id: BlockId) -> RpcResult<u64> {
         let num_trans_count = self.api.starknet.read().await.get_block_txs_count(block_id.into());

crates/starknet-server/src/api/json_rpc/models.rs

@@ -210,7 +210,11 @@ mod tests {
                             "type": "function"
                         }],
                         "program": "",
-                        "entry_points_by_type": {}
+                        "entry_points_by_type": {
+                            "CONSTRUCTOR": [], 
+                            "EXTERNAL": [], 
+                            "L1_HANDLER": []
+                        }
                     }
                 },
                 {

crates/starknet-server/src/api/json_rpc/write_endpoints.rs

@@ -1,10 +1,8 @@
-use serde_json::json;
 use server::rpc_core::error::RpcError;
 use starknet_core::transactions::declare_transaction::DeclareTransactionV1;
 use starknet_core::transactions::declare_transaction_v2::DeclareTransactionV2;
 use starknet_core::transactions::deploy_account_transaction::DeployAccountTransaction;
 use starknet_core::transactions::invoke_transaction::InvokeTransactionV1;
-use starknet_types::contract_class::ContractClass;
 use starknet_types::felt::Felt;
 
 use super::error::ApiError;
@@ -13,7 +11,6 @@ use super::models::{
 };
 use super::RpcResult;
 use crate::api::json_rpc::JsonRpcHandler;
-use crate::api::models::contract_class::DeprecatedContractClass;
 use crate::api::models::transaction::{
     BroadcastedDeclareTransaction, BroadcastedDeclareTransactionV1,
     BroadcastedDeclareTransactionV2, BroadcastedDeployAccountTransaction,
@@ -90,29 +87,6 @@ impl JsonRpcHandler {
     }
 }
 
-impl TryFrom<DeprecatedContractClass> for ContractClass {
-    type Error = ApiError;
-
-    fn try_from(value: DeprecatedContractClass) -> RpcResult<Self> {
-        let abi_json = serde_json::to_value(value.abi).map_err(|_| {
-            ApiError::RpcError(RpcError::invalid_params("abi: Unable to parse to JSON"))
-        })?;
-        let entry_points_json = serde_json::to_value(value.entry_points_by_type).map_err(|_| {
-            ApiError::RpcError(RpcError::invalid_params(
-                "entry_points_by_type: Unable to parse to JSON",
-            ))
-        })?;
-
-        Ok(ContractClass::Cairo0(starknet_types::contract_class::Cairo0ContractClass::Json(
-            json!({
-                "program": value.program,
-                "abi": abi_json,
-                "entry_points_by_type": entry_points_json,
-            }),
-        )))
-    }
-}
-
 pub(crate) fn convert_to_declare_transaction_v1(
     value: BroadcastedDeclareTransactionV1,
     chain_id: Felt,
@@ -122,7 +96,7 @@ pub(crate) fn convert_to_declare_transaction_v1(
         value.common.max_fee.0,
         value.common.signature,
         value.common.nonce,
-        ContractClass::try_from(value.contract_class)?,
+        value.contract_class.into(),
         chain_id,
     )
     .map_err(ApiError::StarknetDevnetError)
@@ -155,7 +129,7 @@ pub(crate) fn convert_to_declare_transaction_v2(
     chain_id: Felt,
 ) -> RpcResult<DeclareTransactionV2> {
     DeclareTransactionV2::new(
-        ContractClass::from(value.contract_class),
+        value.contract_class,
         value.compiled_class_hash,
         value.sender_address,
         value.common.max_fee.0,