feat: Declare V0 RPC call

.gitignore

@@ -44,3 +44,7 @@ cairo_venv
 
 # solidity cache
 tmp/
+
+# Setup deps
+setup_and_launch.sh
+./setup_dir

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Next release
 
+- feat: Declare V0 RPC call
 - feat: actual estimate_fee added, brought back l1 messages and refactored
   simulate tx
 - dev: impl get_state_updates using get_transaction_re_execution_state_diff

configs/genesis-assets/genesis.json

@@ -386,4 +386,4 @@
   "eth_fee_token_address": "0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
   "strk_fee_token_address": "0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
   "chain_id": "MADARA"
-}
+}

configs/index.json

@@ -15,7 +15,7 @@
     },
     {
       "name": "genesis.json",
-      "sha3_256": "bca50369e627d1101e4d693fa6fac9bee6cce2889b324dee3204179a3960ef5e"
+      "sha3_256": "7068787425ff1948e8cd08f136e3db99230751ffb31c4bf7b9384c171a49574f"
     },
     {
       "name": "NoValidateAccount.casm.json",

crates/client/l1-gas-price/src/worker.rs

@@ -66,6 +66,8 @@ async fn update_gas_price(
         .json()
         .await?;
 
+    // log::info!(">>>>>> gas_prices : {:?}", fee_history);
+
     // The RPC responds with 301 elements for some reason. It's also just safer to manually
     // take the last 300. We choose 300 to get average gas caprice for last one hour (300 * 12 sec block
     // time).

crates/client/rpc-core/src/lib.rs

@@ -7,10 +7,15 @@
 #[cfg(test)]
 mod tests;
 
-use jsonrpsee::core::RpcResult;
+use blockifier::transaction::transactions::DeclareTransaction;
+use indexmap::IndexMap;
+use jsonrpsee::core::{async_trait, RpcResult};
 use jsonrpsee::proc_macros::rpc;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
+use starknet_api::core::ClassHash;
+use starknet_api::deprecated_contract_class::{EntryPoint, EntryPointType};
+use starknet_api::transaction::{DeclareTransactionV0V1, TransactionHash};
 
 pub mod utils;
 
@@ -19,11 +24,11 @@ use pallet_starknet::genesis_loader::PredeployedAccount;
 use starknet_core::serde::unsigned_field_element::UfeHex;
 use starknet_core::types::{
     BlockHashAndNumber, BlockId, BroadcastedDeclareTransaction, BroadcastedDeployAccountTransaction,
-    BroadcastedInvokeTransaction, BroadcastedTransaction, ContractClass, DeclareTransactionResult,
-    DeployAccountTransactionResult, EventFilterWithPage, EventsPage, FeeEstimate, FieldElement, FunctionCall,
-    InvokeTransactionResult, MaybePendingBlockWithTxHashes, MaybePendingBlockWithTxs, MaybePendingStateUpdate,
-    MaybePendingTransactionReceipt, MsgFromL1, SimulatedTransaction, SimulationFlag, SimulationFlagForEstimateFee,
-    SyncStatusType, Transaction, TransactionTrace, TransactionTraceWithHash,
+    BroadcastedInvokeTransaction, BroadcastedTransaction, ContractClass,
+    DeclareTransactionResult, DeployAccountTransactionResult, EventFilterWithPage, EventsPage, FeeEstimate,
+    FieldElement, FunctionCall, InvokeTransactionResult, MaybePendingBlockWithTxHashes, MaybePendingBlockWithTxs,
+    MaybePendingStateUpdate, MaybePendingTransactionReceipt, MsgFromL1, SimulatedTransaction, SimulationFlag,
+    SimulationFlagForEstimateFee, SyncStatusType, Transaction, TransactionTrace, TransactionTraceWithHash,
 };
 
 #[serde_as]
@@ -36,11 +41,25 @@ pub struct PredeployedAccountWithBalance {
     pub balance: FieldElement,
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct DeclareV0Result {
+    pub class_hash: ClassHash,
+}
+
 /// Madara rpc interface for additional features.
 #[rpc(server, namespace = "madara")]
 pub trait MadaraRpcApi: StarknetReadRpcApi {
     #[method(name = "predeployedAccounts")]
     fn predeployed_accounts(&self) -> RpcResult<Vec<PredeployedAccountWithBalance>>;
+
+    #[method(name = "declarev0")]
+    async fn declare_v0_contract(
+        &self,
+        declare_transaction: DeclareTransactionV0V1,
+        program_vec: Vec<u8>,
+        entrypoints: IndexMap<EntryPointType, Vec<EntryPoint>>,
+        abi_length: usize,
+    ) -> RpcResult<DeclareV0Result>;
 }
 
 /// Starknet write rpc interface.
@@ -189,3 +208,16 @@ pub trait StarknetTraceRpcApi {
     /// Returns the execution trace of a transaction
     async fn trace_transaction(&self, transaction_hash: FieldElement) -> RpcResult<TransactionTrace>;
 }
+
+pub enum DeclareTransactionCommonInput {
+    V0(DeclareTransactionV0V1, Vec<u8>, IndexMap<EntryPointType, Vec<EntryPoint>>, usize),
+    V1(DeclareTransaction),
+}
+
+#[async_trait]
+pub trait StarknetRpcApiCommonFuncs {
+    async fn declare_txn_common(
+        &self,
+        transaction_inputs: DeclareTransactionCommonInput,
+    ) -> Option<(TransactionHash, ClassHash)>;
+}

crates/client/rpc/Cargo.toml

@@ -50,6 +50,7 @@ starknet-core = { workspace = true }
 starknet-ff = { workspace = true }
 starknet_api = { workspace = true }
 thiserror = { workspace = true }
+indexmap = { workspace = true }
 
 [dev-dependencies]
 rstest = { workspace = true }

crates/client/rpc/src/lib.rs

@@ -15,14 +15,18 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+use blockifier::execution::contract_class::{ClassInfo, ContractClassV0, ContractClassV0Inner};
 use blockifier::transaction::account_transaction::AccountTransaction;
 use blockifier::transaction::objects::{ResourcesMapping, TransactionExecutionInfo};
-use blockifier::transaction::transactions::L1HandlerTransaction;
+use blockifier::transaction::transactions::{DeclareTransaction, L1HandlerTransaction};
+use cairo_vm::types::program::Program;
+use indexmap::IndexMap;
 use errors::StarknetRpcApiError;
 use jsonrpsee::core::{async_trait, RpcResult};
 use log::error;
 use mc_genesis_data_provider::GenesisProvider;
 pub use mc_rpc_core::utils::*;
+use mc_rpc_core::{DeclareTransactionCommonInput, DeclareV0Result, StarknetRpcApiCommonFuncs};
 pub use mc_rpc_core::{
     Felt, MadaraRpcApiServer, PredeployedAccountWithBalance, StarknetReadRpcApiServer, StarknetTraceRpcApiServer,
     StarknetWriteRpcApiServer,
@@ -50,23 +54,25 @@ use sp_api::ProvideRuntimeApi;
 use sp_arithmetic::traits::UniqueSaturatedInto;
 use sp_blockchain::HeaderBackend;
 use sp_core::H256;
+use sp_runtime::codec::{DecodeAll};
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 use sp_runtime::transaction_validity::InvalidTransaction;
-use starknet_api::core::Nonce;
-use starknet_api::hash::StarkFelt;
-use starknet_api::transaction::{Calldata, Fee, TransactionHash, TransactionVersion};
+use starknet_api::core::{ClassHash, Nonce};
+use starknet_api::deprecated_contract_class::{EntryPoint, EntryPointType};
+use starknet_api::hash::{StarkFelt, StarkHash};
+use starknet_api::transaction::{Calldata, DeclareTransactionV0V1, Fee, TransactionHash, TransactionVersion};
 use starknet_core::types::{
     BlockHashAndNumber, BlockId, BlockStatus, BlockTag, BlockWithTxHashes, BlockWithTxs, BroadcastedDeclareTransaction,
-    BroadcastedDeployAccountTransaction, BroadcastedInvokeTransaction, BroadcastedTransaction, ContractClass,
-    DeclareTransactionReceipt, DeclareTransactionResult, DeployAccountTransactionReceipt,
-    DeployAccountTransactionResult, EventFilterWithPage, EventsPage, ExecutionResources, ExecutionResult, FeeEstimate,
-    FeePayment, FieldElement, FunctionCall, Hash256, InvokeTransactionReceipt, InvokeTransactionResult,
-    L1HandlerTransactionReceipt, MaybePendingBlockWithTxHashes, MaybePendingBlockWithTxs, MaybePendingStateUpdate,
-    MaybePendingTransactionReceipt, MsgFromL1, PendingBlockWithTxHashes, PendingBlockWithTxs,
-    PendingDeclareTransactionReceipt, PendingDeployAccountTransactionReceipt, PendingInvokeTransactionReceipt,
-    PendingL1HandlerTransactionReceipt, PendingStateUpdate, PendingTransactionReceipt, PriceUnit, ResourcePrice,
-    SimulationFlagForEstimateFee, StateDiff, StateUpdate, SyncStatus, SyncStatusType, Transaction,
-    TransactionExecutionStatus, TransactionFinalityStatus, TransactionReceipt,
+    BroadcastedDeployAccountTransaction, BroadcastedInvokeTransaction, BroadcastedTransaction, ContractClass, DeclareTransactionReceipt, DeclareTransactionResult,
+    DeployAccountTransactionReceipt, DeployAccountTransactionResult, EventFilterWithPage, EventsPage,
+    ExecutionResources, ExecutionResult, FeeEstimate, FeePayment, FieldElement, FunctionCall, Hash256,
+    InvokeTransactionReceipt, InvokeTransactionResult, L1HandlerTransactionReceipt, MaybePendingBlockWithTxHashes,
+    MaybePendingBlockWithTxs, MaybePendingStateUpdate, MaybePendingTransactionReceipt, MsgFromL1,
+    PendingBlockWithTxHashes, PendingBlockWithTxs, PendingDeclareTransactionReceipt,
+    PendingDeployAccountTransactionReceipt, PendingInvokeTransactionReceipt, PendingL1HandlerTransactionReceipt,
+    PendingStateUpdate, PendingTransactionReceipt, PriceUnit, ResourcePrice, SimulationFlagForEstimateFee, StateDiff,
+    StateUpdate, SyncStatus, SyncStatusType, Transaction, TransactionExecutionStatus, TransactionFinalityStatus,
+    TransactionReceipt,
 };
 use starknet_core::utils::get_selector_from_name;
 use trace_api::get_previous_block_substrate_hash;
@@ -220,9 +226,101 @@ where
     }
 }
 
+#[async_trait]
+impl<A, B, BE, G, C, P, H> StarknetRpcApiCommonFuncs for Starknet<A, B, BE, G, C, P, H>
+where
+    A: ChainApi<Block = B> + 'static,
+    B: BlockT,
+    P: TransactionPool<Block = B> + 'static,
+    BE: Backend<B> + 'static,
+    C: HeaderBackend<B> + BlockBackend<B> + StorageProvider<B, BE> + 'static,
+    C: ProvideRuntimeApi<B>,
+    C::Api: StarknetRuntimeApi<B> + ConvertTransactionRuntimeApi<B>,
+    G: GenesisProvider + Send + Sync + 'static,
+    H: HasherT + Send + Sync + 'static,
+{
+    async fn declare_txn_common(
+        &self,
+        transaction_inputs: DeclareTransactionCommonInput,
+    ) -> Option<(TransactionHash, ClassHash)> {
+        let best_block_hash = self.get_best_block_hash();
+
+        match transaction_inputs {
+            DeclareTransactionCommonInput::V1(transaction) => {
+                let (class_hash, tx_hash) = (transaction.class_hash(), transaction.tx_hash());
+
+                let current_block_hash = self.get_best_block_hash();
+                let contract_class = self
+                    .overrides
+                    .for_block_hash(self.client.as_ref(), current_block_hash)
+                    .contract_class_by_class_hash(current_block_hash, class_hash);
+
+                if let Some(contract_class) = contract_class {
+                    error!("Contract class already exists: {:?}", contract_class);
+                    // return Err(StarknetRpcApiError::ClassAlreadyDeclared.into());
+                }
+
+                let extrinsic =
+                    self.convert_tx_to_extrinsic(best_block_hash, AccountTransaction::Declare(transaction)).unwrap();
+
+                submit_extrinsic(self.pool.clone(), best_block_hash, extrinsic).await.ok()?;
+
+                Some((tx_hash, class_hash))
+            }
+            DeclareTransactionCommonInput::V0(declare_txn, program_vec, entrypoints, abi_length) => {
+                let txn_hash: TransactionHash = TransactionHash(StarkHash { 0: FieldElement::ONE.to_bytes_be() });
+
+                let program_decoded = Program::decode_all(&mut &*program_vec).unwrap();
+
+                let class_info = ClassInfo::new(
+                    &blockifier::execution::contract_class::ContractClass::V0(ContractClassV0(Arc::from(
+                        ContractClassV0Inner {
+                            program: program_decoded,
+                            entry_points_by_type: entrypoints,
+                        },
+                    ))),
+                    0,
+                    abi_length,
+                )
+                .unwrap();
+
+                let declare_transaction = DeclareTransaction::new(
+                    starknet_api::transaction::DeclareTransaction::V0(declare_txn),
+                    txn_hash,
+                    class_info,
+                )
+                .unwrap();
+
+                let current_block_hash = self.get_best_block_hash();
+                let contract_class = self
+                    .overrides
+                    .for_block_hash(self.client.as_ref(), current_block_hash)
+                    .contract_class_by_class_hash(current_block_hash, declare_transaction.class_hash());
+
+                if let Some(contract_class) = contract_class {
+                    error!("Contract class already exists: {:?}", contract_class);
+                    // return Err(StarknetRpcApiError::ClassAlreadyDeclared.into());
+                }
+
+                let extrinsic = self
+                    .convert_tx_to_extrinsic(best_block_hash, AccountTransaction::Declare(declare_transaction.clone()))
+                    .unwrap();
+
+                let res = submit_extrinsic(self.pool.clone(), best_block_hash, extrinsic).await.unwrap();
+
+                log::info!(">>>>> extrinsic res : {:?}", res);
+                log::info!(">>>>> class hash declared: {:?} ✅ | txn hash : {:?}", declare_transaction.class_hash(), declare_transaction.tx_hash);
+
+                Some((declare_transaction.tx_hash, declare_transaction.class_hash()))
+            }
+        }
+    }
+}
+
 /// Taken from https://github.com/paritytech/substrate/blob/master/client/rpc/src/author/mod.rs#L78
 const TX_SOURCE: TransactionSource = TransactionSource::External;
 
+#[async_trait]
 impl<A, B, BE, G, C, P, H> MadaraRpcApiServer for Starknet<A, B, BE, G, C, P, H>
 where
     A: ChainApi<Block = B> + 'static,
@@ -262,6 +360,20 @@ where
             })
             .collect::<Vec<_>>())
     }
+
+    async fn declare_v0_contract(
+        &self,
+        declare_transaction: DeclareTransactionV0V1,
+        program_vec: Vec<u8>,
+        entrypoints: IndexMap<EntryPointType, Vec<EntryPoint>>,
+        abi_length: usize
+    ) -> RpcResult<DeclareV0Result> {
+        let (_txn_hash, class_hash) = self.declare_txn_common(DeclareTransactionCommonInput::V0(declare_transaction, program_vec, entrypoints, abi_length))
+            .await
+            .ok_or("Error in declaring the v0 using the given transaction !!!").expect("ERROR : Error in declaring the v0 using the given transaction !!!");
+
+        Ok(DeclareV0Result { class_hash })
+    }
 }
 
 #[async_trait]
@@ -290,8 +402,6 @@ where
         &self,
         declare_transaction: BroadcastedDeclareTransaction,
     ) -> RpcResult<DeclareTransactionResult> {
-        let best_block_hash = self.get_best_block_hash();
-
         let opt_sierra_contract_class = if let BroadcastedDeclareTransaction::V2(ref tx) = declare_transaction {
             Some(flattened_sierra_to_sierra_contract_class(tx.contract_class.clone()))
         } else {
@@ -304,22 +414,9 @@ where
             error!("Failed to convert BroadcastedDeclareTransaction to DeclareTransaction, error: {e}");
             StarknetRpcApiError::InternalServerError
         })?;
-        let (class_hash, tx_hash) = (transaction.class_hash(), transaction.tx_hash());
-
-        let current_block_hash = self.get_best_block_hash();
-        let contract_class = self
-            .overrides
-            .for_block_hash(self.client.as_ref(), current_block_hash)
-            .contract_class_by_class_hash(current_block_hash, class_hash);
-
-        if let Some(contract_class) = contract_class {
-            error!("Contract class already exists: {:?}", contract_class);
-            return Err(StarknetRpcApiError::ClassAlreadyDeclared.into());
-        }
 
-        let extrinsic = self.convert_tx_to_extrinsic(best_block_hash, AccountTransaction::Declare(transaction))?;
-
-        submit_extrinsic(self.pool.clone(), best_block_hash, extrinsic).await?;
+        let (tx_hash, class_hash) =
+            self.declare_txn_common(DeclareTransactionCommonInput::V1(transaction)).await.unwrap();
 
         if let Some(sierra_contract_class) = opt_sierra_contract_class {
             if let Some(e) = self.backend.sierra_classes().store_sierra_class(class_hash, sierra_contract_class).err() {
@@ -1697,7 +1794,9 @@ where
     pool.submit_one(best_block_hash, TX_SOURCE, extrinsic).await.map_err(|e| {
         error!("Failed to submit extrinsic: {:?}", e);
         match e.into_pool_error() {
-            Ok(PoolError::InvalidTransaction(InvalidTransaction::BadProof)) => StarknetRpcApiError::ValidationFailure,
+            Ok(PoolError::InvalidTransaction(InvalidTransaction::BadProof)) => {
+                StarknetRpcApiError::ValidationFailure
+            },
             _ => StarknetRpcApiError::InternalServerError,
         }
     })