feat: add types for v0.10.0 RPC

Author: prkpndy

madara/crates/primitives/block/src/event_with_info.rs

@@ -40,6 +40,20 @@ impl From<EventWithInfo> for mp_rpc::v0_7_1::EmittedEvent {
     }
 }
 
+impl From<EventWithInfo> for mp_rpc::v0_10_0::EmittedEvent {
+    fn from(event_with_info: EventWithInfo) -> Self {
+        mp_rpc::v0_10_0::EmittedEvent {
+            event: event_with_info.event.into(),
+            block_hash: event_with_info.block_hash,
+            // v0_10_0 expects None when the event is in the pending block.
+            block_number: if event_with_info.in_preconfirmed { None } else { Some(event_with_info.block_number) },
+            transaction_hash: event_with_info.transaction_hash,
+            transaction_index: event_with_info.transaction_index,
+            event_index: event_with_info.event_index_in_block,
+        }
+    }
+}
+
 /// Filters events based on the provided address and keys.
 ///
 /// This function checks if an event matches the given address and keys.

madara/crates/primitives/chain_config/src/rpc_version.rs

@@ -1,10 +1,11 @@
 use std::hash::Hash;
 use std::str::FromStr;
 
-const SUPPORTED_RPC_VERSIONS: [RpcVersion; 4] = [
+const SUPPORTED_RPC_VERSIONS: [RpcVersion; 5] = [
     RpcVersion::RPC_VERSION_0_7_1,
     RpcVersion::RPC_VERSION_0_8_1,
     RpcVersion::RPC_VERSION_0_9_0,
+    RpcVersion::RPC_VERSION_0_10_0,
     RpcVersion::RPC_VERSION_ADMIN_0_1_0,
 ];
 
@@ -86,7 +87,8 @@ impl RpcVersion {
     pub const RPC_VERSION_0_7_1: RpcVersion = RpcVersion([0, 7, 1]);
     pub const RPC_VERSION_0_8_1: RpcVersion = RpcVersion([0, 8, 1]);
     pub const RPC_VERSION_0_9_0: RpcVersion = RpcVersion([0, 9, 0]);
-    pub const RPC_VERSION_LATEST: RpcVersion = Self::RPC_VERSION_0_9_0;
+    pub const RPC_VERSION_0_10_0: RpcVersion = RpcVersion([0, 10, 0]);
+    pub const RPC_VERSION_LATEST: RpcVersion = Self::RPC_VERSION_0_10_0;
 
     pub const RPC_VERSION_ADMIN_0_1_0: RpcVersion = RpcVersion([0, 1, 0]);
     pub const RPC_VERSION_LATEST_ADMIN: RpcVersion = Self::RPC_VERSION_ADMIN_0_1_0;

madara/crates/primitives/gateway/src/state_update.rs

@@ -102,6 +102,7 @@ impl From<StateDiff> for mp_state_update::StateDiff {
                 .into_iter()
                 .map(|(contract_address, nonce)| mp_state_update::NonceUpdate { contract_address, nonce })
                 .collect(),
+            migrated_compiled_classes: vec![], // TODO(prakhar,22/11/2025): Add migrated compiled classes here
         }
     }
 }

madara/crates/primitives/rpc/src/lib.rs

@@ -4,3 +4,4 @@ pub mod admin;
 pub mod v0_7_1;
 pub mod v0_8_1;
 pub mod v0_9_0;
+pub mod v0_10_0;

madara/crates/primitives/rpc/src/v0_10_0/mod.rs

@@ -0,0 +1,132 @@
+//! v0.10.0 of the API.
+mod starknet_api_openrpc;
+mod starknet_trace_api_openrpc;
+mod starknet_ws_api;
+
+pub use self::starknet_api_openrpc::*;
+pub use self::starknet_trace_api_openrpc::*;
+pub use self::starknet_ws_api::*;
+
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+pub enum BlockId {
+    /// The tag of the block.
+    Tag(BlockTag),
+    /// The hash of the block.
+    Hash(BlockHash),
+    /// The height of the block.
+    Number(BlockNumber),
+}
+
+impl serde::Serialize for BlockId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            BlockId::Tag(tag) => tag.serialize(serializer),
+            BlockId::Hash(block_hash) => BlockHashHelper { block_hash: *block_hash }.serialize(serializer),
+            BlockId::Number(block_number) => BlockNumberHelper { block_number: *block_number }.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for BlockId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let helper = BlockIdHelper::deserialize(deserializer)?;
+        match helper {
+            BlockIdHelper::Tag(tag) => Ok(BlockId::Tag(tag)),
+            BlockIdHelper::Hash(helper) => Ok(BlockId::Hash(helper.block_hash)),
+            BlockIdHelper::Number(helper) => Ok(BlockId::Number(helper.block_number)),
+        }
+    }
+}
+
+#[derive(serde::Deserialize)]
+#[serde(untagged)]
+enum BlockIdHelper {
+    Tag(BlockTag),
+    Hash(BlockHashHelper),
+    Number(BlockNumberHelper),
+}
+
+#[test]
+fn block_id_from_hash() {
+    pub use starknet_types_core::felt::Felt;
+
+    let s = "{\"block_hash\":\"0x123\"}";
+    let block_id: BlockId = serde_json::from_str(s).unwrap();
+    assert_eq!(block_id, BlockId::Hash(Felt::from_hex("0x123").unwrap()));
+}
+
+#[test]
+fn block_id_from_number() {
+    let s = "{\"block_number\":123}";
+    let block_id: BlockId = serde_json::from_str(s).unwrap();
+    assert_eq!(block_id, BlockId::Number(123));
+}
+
+#[test]
+fn block_id_from_latest() {
+    let s = "\"latest\"";
+    let block_id: BlockId = serde_json::from_str(s).unwrap();
+    assert_eq!(block_id, BlockId::Tag(BlockTag::Latest));
+}
+
+#[test]
+fn block_id_from_pre_confirmed() {
+    let s = "\"pre_confirmed\"";
+    let block_id: BlockId = serde_json::from_str(s).unwrap();
+    assert_eq!(block_id, BlockId::Tag(BlockTag::PreConfirmed));
+}
+
+#[test]
+fn block_id_from_l1_accepted() {
+    let s = "\"l1_accepted\"";
+    let block_id: BlockId = serde_json::from_str(s).unwrap();
+    assert_eq!(block_id, BlockId::Tag(BlockTag::L1Accepted));
+}
+
+#[cfg(test)]
+#[test]
+fn block_id_to_hash() {
+    pub use starknet_types_core::felt::Felt;
+
+    let block_id = BlockId::Hash(Felt::from_hex("0x123").unwrap());
+    let s = serde_json::to_string(&block_id).unwrap();
+    assert_eq!(s, "{\"block_hash\":\"0x123\"}");
+}
+
+#[cfg(test)]
+#[test]
+fn block_id_to_number() {
+    let block_id = BlockId::Number(123);
+    let s = serde_json::to_string(&block_id).unwrap();
+    assert_eq!(s, "{\"block_number\":123}");
+}
+
+#[cfg(test)]
+#[test]
+fn block_id_to_latest() {
+    let block_id = BlockId::Tag(BlockTag::Latest);
+    let s = serde_json::to_string(&block_id).unwrap();
+    assert_eq!(s, "\"latest\"");
+}
+
+#[cfg(test)]
+#[test]
+fn block_id_to_pre_confirmed() {
+    let block_id = BlockId::Tag(BlockTag::PreConfirmed);
+    let s = serde_json::to_string(&block_id).unwrap();
+    assert_eq!(s, "\"pre_confirmed\"");
+}
+
+#[cfg(test)]
+#[test]
+fn block_id_to_l1_accepted() {
+    let block_id = BlockId::Tag(BlockTag::L1Accepted);
+    let s = serde_json::to_string(&block_id).unwrap();
+    assert_eq!(s, "\"l1_accepted\"");
+}

madara/crates/primitives/rpc/src/v0_10_0/starknet_api_openrpc.rs

@@ -0,0 +1,108 @@
+pub use crate::v0_9_0::{
+    AddDeclareTransactionParams, AddDeployAccountTransactionParams, AddInvokeTransactionParams,
+    AddInvokeTransactionResult, Address, BlockHash, BlockHashAndNumber, BlockHashAndNumberParams, BlockHashHelper,
+    BlockHeader, BlockNumber, BlockNumberHelper, BlockNumberParams, BlockStatus, BlockTag, BlockWithReceipts,
+    BlockWithTxHashes, BlockWithTxs, BroadcastedDeclareTxn, BroadcastedDeclareTxnV1, BroadcastedDeclareTxnV2,
+    BroadcastedDeclareTxnV3, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn, BroadcastedTxn, CallParams,
+    ChainId, ChainIdParams, ClassAndTxnHash, CommonReceiptProperties, ContractAbi, ContractAbiEntry,
+    ContractAndTxnHash, ContractClass, ContractLeavesDataItem, ContractStorageDiffItem,
+    ContractsProof, DaMode, DataAvailability, DeclareTxn, DeclareTxnReceipt, DeclareTxnV0, DeclareTxnV1,
+    DeclareTxnV2, DeclareTxnV3, DeployAccountTxn, DeployAccountTxnReceipt, DeployAccountTxnV1, DeployAccountTxnV3,
+    DeployTxn, DeployTxnReceipt, DeployedContractItem, DeprecatedCairoEntryPoint, DeprecatedContractClass,
+    DeprecatedEntryPointsByType, EntryPointsByType, EstimateFeeParams, EstimateMessageFeeParams, EthAddress,
+    Event, EventAbiEntry, EventAbiType, EventContent, EventFilterWithPageRequest, EventsChunk, ExecutionResources,
+    ExecutionStatus, FeeEstimate, FeeEstimateCommon, FeePayment, FunctionAbiEntry, FunctionAbiType, FunctionCall, FunctionStateMutability,
+    GetBlockTransactionCountParams, GetBlockWithReceiptsParams, GetBlockWithTxHashesParams, GetBlockWithTxsParams,
+    GetClassAtParams, GetClassHashAtParams, GetClassParams, GetEventsParams, GetNonceParams, GetStateUpdateParams,
+    GetStorageAtParams, GetStorageProofResult, GetTransactionByBlockIdAndIndexParams, GetTransactionByHashParams,
+    GetTransactionReceiptParams, GetTransactionStatusParams, GlobalRoots, InvokeTxn, InvokeTxnReceipt,
+    InvokeTxnV0, InvokeTxnV1, InvokeTxnV3, KeyValuePair, L1DaMode, L1HandlerTxn, L1HandlerTxnReceipt,
+    MaybeDeprecatedContractClass, MaybePreConfirmedBlockWithTxHashes, MaybePreConfirmedBlockWithTxs,
+    MessageFeeEstimate,
+    MerkleNode, MsgFromL1, MsgToL1, NewClasses, NodeHashToNodeMappingItem, NonceUpdate, PriceUnitFri, PriceUnitWei,
+    PreConfirmedBlockHeader, PreConfirmedBlockWithReceipts, PreConfirmedBlockWithTxHashes,
+    PreConfirmedBlockWithTxs, ReplacedClass, ResourceBounds, ResourceBoundsMapping, ResourcePrice,
+    SierraEntryPoint, Signature, SimulationFlagForEstimateFee, SpecVersionParams, StateUpdate, StorageKey,
+    StarknetGetBlockWithTxsAndReceiptsResult, StructAbiEntry, StructAbiType, StructMember, SyncStatus,
+    SyncingParams, SyncingStatus, TransactionAndReceipt, Txn, TxnExecutionStatus, TxnFinalityAndExecutionStatus,
+    TxnFinalityStatus, TxnHash, TxnReceipt, TxnReceiptWithBlockInfo, TxnStatus, TxnWithHash, TypedParameter,
+};
+use serde::{Deserialize, Serialize};
+use starknet_types_core::felt::Felt;
+
+/// RPC 0.10.0 Changes:
+/// 1. StateDiff: Added `migrated_compiled_classes` field
+/// 2. PreConfirmedStateUpdate: Removed `old_root` field
+/// 3. EmittedEvent: Added `transaction_index` and `event_index` fields
+/// 4. ContractStorageKeysItem: Changed `storage_keys` type from `Vec<Felt>` to `Vec<StorageKey>`
+
+/// The change in state applied in this block, given as a mapping of addresses to the new values and/or new contracts
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct StateDiff {
+    /// The declared class hash and compiled class hash
+    pub declared_classes: Vec<NewClasses>,
+    /// The deployed contracts
+    pub deployed_contracts: Vec<DeployedContractItem>,
+    /// The hash of the declared class
+    pub deprecated_declared_classes: Vec<Felt>,
+    /// The nonce updates
+    pub nonces: Vec<NonceUpdate>,
+    /// The replaced classes
+    pub replaced_classes: Vec<ReplacedClass>,
+    /// The storage diffs
+    pub storage_diffs: Vec<ContractStorageDiffItem>,
+    /// The migrated compiled classes (NEW in v0.10.0)
+    pub migrated_compiled_classes: Vec<MigratedClassItem>,
+}
+
+/// A migrated class item representing a class that was migrated from Poseidon to BLAKE hash
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct MigratedClassItem {
+    /// The hash of the declared class
+    pub class_hash: Felt,
+    /// The new BLAKE hash (post-SNIP-34)
+    pub compiled_class_hash: Felt,
+}
+
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
+#[serde(untagged)]
+pub enum MaybePreConfirmedStateUpdate {
+    Block(StateUpdate),
+    PreConfirmed(PreConfirmedStateUpdate),
+}
+
+/// Pre-confirmed state update (v0.10.0: removed `old_root` field)
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct PreConfirmedStateUpdate {
+    /// The state diff
+    pub state_diff: StateDiff,
+}
+
+/// An event emitted as part of a transaction (v0.10.0: added transaction_index and event_index)
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct EmittedEvent {
+    /// The event information
+    #[serde(flatten)]
+    pub event: Event,
+    /// The hash of the block in which the event was emitted
+    #[serde(default)]
+    pub block_hash: Option<BlockHash>,
+    /// The number of the block in which the event was emitted
+    #[serde(default)]
+    pub block_number: Option<BlockNumber>,
+    /// The transaction that emitted the event
+    pub transaction_hash: TxnHash,
+    /// The index of the transaction within the block
+    pub transaction_index: u64,
+    /// The index of the event within the transaction
+    pub event_index: u64,
+}
+
+/// Contract storage keys item (v0.10.0: changed storage_keys type from Vec<Felt> to Vec<StorageKey>)
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ContractStorageKeysItem {
+    /// The address of the contract
+    pub contract_address: Felt,
+    /// The storage keys (changed from Vec<Felt> to Vec<StorageKey> in v0.10.0)
+    pub storage_keys: Vec<StorageKey>,
+}

madara/crates/primitives/rpc/src/v0_10_0/starknet_trace_api_openrpc.rs

@@ -0,0 +1,6 @@
+pub use crate::v0_9_0::{
+    CallType, DeclareTransactionTrace, DeployAccountTransactionTrace, EntryPointType,
+    InvokeTransactionTrace, L1HandlerTransactionTrace, OrderedEvent, OrderedMessage,
+    RevertedInvocation, RevertibleFunctionInvocation, SimulationFlag, SimulateTransactionsResult,
+    TraceBlockTransactionsResult, TraceTransactionResult, TransactionTrace,
+};

madara/crates/primitives/rpc/src/v0_10_0/starknet_ws_api.rs

@@ -0,0 +1,14 @@
+use serde::{Deserialize, Serialize};
+
+use super::{EmittedEvent, TxnFinalityStatus};
+
+pub use crate::v0_9_0::FinalityStatus;
+
+/// An emitted event with finality status for WebSocket subscriptions
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct EmittedEventWithFinality {
+    #[serde(flatten)]
+    pub emitted_event: EmittedEvent,
+    #[serde(flatten)]
+    pub finality_status: TxnFinalityStatus,
+}

madara/crates/primitives/state_update/src/into_starknet_types.rs

@@ -58,6 +58,7 @@ impl From<mp_rpc::v0_7_1::StateDiff> for StateDiff {
                 .map(|replaced_class| replaced_class.into())
                 .collect(),
             nonces: state_diff.nonces.into_iter().map(|nonce| nonce.into()).collect(),
+            migrated_compiled_classes: vec![], // v0.7.1 doesn't have migrated classes
         }
     }
 }
@@ -171,6 +172,61 @@ impl From<NonceUpdate> for mp_rpc::v0_7_1::NonceUpdate {
     }
 }
 
+// v0.10.0 conversions
+impl From<StateDiff> for mp_rpc::v0_10_0::StateDiff {
+    fn from(state_diff: StateDiff) -> Self {
+        Self {
+            storage_diffs: state_diff
+                .storage_diffs
+                .into_iter()
+                .map(|diff| mp_rpc::v0_10_0::ContractStorageDiffItem {
+                    address: diff.address,
+                    storage_entries: diff
+                        .storage_entries
+                        .into_iter()
+                        .map(|entry| mp_rpc::v0_10_0::KeyValuePair { key: entry.key, value: entry.value })
+                        .collect(),
+                })
+                .collect(),
+            deprecated_declared_classes: state_diff.old_declared_contracts,
+            declared_classes: state_diff
+                .declared_classes
+                .into_iter()
+                .map(|item| mp_rpc::v0_10_0::NewClasses {
+                    class_hash: item.class_hash,
+                    compiled_class_hash: item.compiled_class_hash,
+                })
+                .collect(),
+            deployed_contracts: state_diff
+                .deployed_contracts
+                .into_iter()
+                .map(|item| mp_rpc::v0_10_0::DeployedContractItem { address: item.address, class_hash: item.class_hash })
+                .collect(),
+            replaced_classes: state_diff
+                .replaced_classes
+                .into_iter()
+                .map(|item| mp_rpc::v0_10_0::ReplacedClass {
+                    contract_address: item.contract_address,
+                    class_hash: item.class_hash,
+                })
+                .collect(),
+            nonces: state_diff
+                .nonces
+                .into_iter()
+                .map(|item| mp_rpc::v0_10_0::NonceUpdate { contract_address: item.contract_address, nonce: item.nonce })
+                .collect(),
+            migrated_compiled_classes: state_diff
+                .migrated_compiled_classes
+                .into_iter()
+                .map(|item| mp_rpc::v0_10_0::MigratedClassItem {
+                    class_hash: item.class_hash,
+                    compiled_class_hash: item.compiled_class_hash,
+                })
+                .collect(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;