From dd4c1c1a5f36cdce2fbc0b928a188f313502b9b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20Kami=C5=84ski?= <aundumla@gmail.com>
Date: Wed, 3 Jul 2024 15:18:20 +0200
Subject: [PATCH] add V3 transaction variants, generate with updated openrpc

---
 .../starknet-types-rpc/src/custom/block_id.rs |  24 +-
 crates/starknet-types-rpc/src/custom/query.rs |  25 +-
 .../src/custom/syncing_status.rs              |   6 +-
 crates/starknet-types-rpc/src/lib.rs          |   1 +
 crates/starknet-types-rpc/src/v0_7_1/mod.rs   |   3 -
 .../src/v0_7_1/starknet_api_openrpc.rs        | 335 ++++++++++--------
 .../src/v0_7_1/starknet_api_openrpc.toml      |   6 +-
 .../src/v0_7_1/starknet_trace_api_openrpc.rs  |  60 ++--
 .../v0_7_1/starknet_trace_api_openrpc.toml    |   5 +-
 .../src/v0_7_1/starknet_write_api.rs          |  33 +-
 .../src/v0_7_1/starknet_write_api.toml        |   5 +-
 11 files changed, 283 insertions(+), 220 deletions(-)

diff --git a/crates/starknet-types-rpc/src/custom/block_id.rs b/crates/starknet-types-rpc/src/custom/block_id.rs
index 3cd469ba..632fc115 100644
--- a/crates/starknet-types-rpc/src/custom/block_id.rs
+++ b/crates/starknet-types-rpc/src/custom/block_id.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Deserializer, Serialize};
 use crate::{BlockHash, BlockNumber, BlockTag};
 
 /// A hexadecimal number.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
 pub enum BlockId<F> {
     /// The tag of the block.
     Tag(BlockTag),
@@ -31,19 +31,19 @@ enum BlockIdHelper<F> {
     Number(BlockNumberHelper),
 }
 
-impl<F: Copy + Serialize> serde::Serialize for BlockId<F> {
+impl<F: Serialize> serde::Serialize for BlockId<F> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        match *self {
+        match self {
             BlockId::Tag(tag) => tag.serialize(serializer),
             BlockId::Hash(block_hash) => {
                 let helper = BlockHashHelper { block_hash };
                 helper.serialize(serializer)
             }
             BlockId::Number(block_number) => {
-                let helper = BlockNumberHelper { block_number };
+                let helper = BlockNumberHelper { block_number: *block_number };
                 helper.serialize(serializer)
             }
         }
@@ -66,7 +66,7 @@ impl<'de, F: Deserialize<'de>> serde::Deserialize<'de> for BlockId<F> {
 
 #[test]
 fn block_id_from_hash() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let s = "{\"block_hash\":\"0x123\"}";
     let block_id: BlockId<Felt> = serde_json::from_str(s).unwrap();
@@ -75,7 +75,7 @@ fn block_id_from_hash() {
 
 #[test]
 fn block_id_from_number() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let s = "{\"block_number\":123}";
     let block_id: BlockId<Felt> = serde_json::from_str(s).unwrap();
@@ -84,7 +84,7 @@ fn block_id_from_number() {
 
 #[test]
 fn block_id_from_latest() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let s = "\"latest\"";
     let block_id: BlockId<Felt> = serde_json::from_str(s).unwrap();
@@ -93,7 +93,7 @@ fn block_id_from_latest() {
 
 #[test]
 fn block_id_from_pending() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let s = "\"pending\"";
     let block_id: BlockId<Felt> = serde_json::from_str(s).unwrap();
@@ -103,7 +103,7 @@ fn block_id_from_pending() {
 #[cfg(test)]
 #[test]
 fn block_id_to_hash() {
-    use crate::Felt;
+    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();
@@ -113,7 +113,7 @@ fn block_id_to_hash() {
 #[cfg(test)]
 #[test]
 fn block_id_to_number() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let block_id = BlockId::<Felt>::Number(123);
     let s = serde_json::to_string(&block_id).unwrap();
@@ -123,7 +123,7 @@ fn block_id_to_number() {
 #[cfg(test)]
 #[test]
 fn block_id_to_latest() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let block_id = BlockId::<Felt>::Tag(BlockTag::Latest);
     let s = serde_json::to_string(&block_id).unwrap();
@@ -133,7 +133,7 @@ fn block_id_to_latest() {
 #[cfg(test)]
 #[test]
 fn block_id_to_pending() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let block_id = BlockId::<Felt>::Tag(BlockTag::Pending);
     let s = serde_json::to_string(&block_id).unwrap();
diff --git a/crates/starknet-types-rpc/src/custom/query.rs b/crates/starknet-types-rpc/src/custom/query.rs
index 1d0bd472..af8ef11f 100644
--- a/crates/starknet-types-rpc/src/custom/query.rs
+++ b/crates/starknet-types-rpc/src/custom/query.rs
@@ -3,26 +3,30 @@
 
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    BroadcastedDeclareTxnV1, BroadcastedDeclareTxnV2, DeployAccountTxnV1, InvokeTxnV0, InvokeTxnV1,
-};
+use crate::{BroadcastedDeclareTxnV1, BroadcastedDeclareTxnV2, BroadcastedDeclareTxnV3,
+            DeployAccountTxnV1, DeployAccountTxnV3, InvokeTxnV0, InvokeTxnV1, InvokeTxnV3};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "version")]
 pub enum BroadcastedDeclareTxn<F: Default> {
     #[serde(rename = "0x1")]
     V1(BroadcastedDeclareTxnV1<F>),
     #[serde(rename = "0x2")]
     V2(BroadcastedDeclareTxnV2<F>),
+    #[serde(rename = "0x3")]
+    V3(BroadcastedDeclareTxnV3<F>),
     /// Query-only broadcasted declare transaction.
     #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000001")]
     QueryV1(BroadcastedDeclareTxnV1<F>),
     /// Query-only broadcasted declare transaction.
     #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000002")]
     QueryV2(BroadcastedDeclareTxnV2<F>),
+    /// Query-only broadcasted declare transaction.
+    #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000003")]
+    QueryV3(BroadcastedDeclareTxnV3<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "version")]
 pub enum BroadcastedDeployAccountTxn<F> {
     #[serde(rename = "0x1")]
@@ -30,19 +34,28 @@ pub enum BroadcastedDeployAccountTxn<F> {
     /// Query-only broadcasted deploy account transaction.
     #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000001")]
     QueryV1(DeployAccountTxnV1<F>),
+    /// Query-only broadcasted deploy account transaction.
+    #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000003")]
+    QueryV3(DeployAccountTxnV3<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "version")]
 pub enum BroadcastedInvokeTxn<F> {
     #[serde(rename = "0x0")]
     V0(InvokeTxnV0<F>),
     #[serde(rename = "0x1")]
     V1(InvokeTxnV1<F>),
+    #[serde(rename = "0x3")]
+    V3(InvokeTxnV3<F>),
+
     /// Query-only broadcasted invoke transaction.
     #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000000")]
     QueryV0(InvokeTxnV0<F>),
     /// Query-only broadcasted invoke transaction.
     #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000001")]
     QueryV1(InvokeTxnV1<F>),
+    /// Query-only broadcasted invoke transaction.
+    #[serde(rename = "0x0000000000000000000000000000000100000000000000000000000000000003")]
+    QueryV3(InvokeTxnV3<F>),
 }
diff --git a/crates/starknet-types-rpc/src/custom/syncing_status.rs b/crates/starknet-types-rpc/src/custom/syncing_status.rs
index 3e1744b1..ff94dbe0 100644
--- a/crates/starknet-types-rpc/src/custom/syncing_status.rs
+++ b/crates/starknet-types-rpc/src/custom/syncing_status.rs
@@ -72,7 +72,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for SyncingStatus<F> {
 #[cfg(test)]
 #[test]
 fn syncing_status_from_false() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
 
     let s = "false";
     let syncing_status: SyncingStatus<Felt> = serde_json::from_str(s).unwrap();
@@ -82,7 +82,7 @@ fn syncing_status_from_false() {
 #[cfg(test)]
 #[test]
 fn syncing_status_to_false() {
-    use crate::Felt;
+        pub use starknet_types_core::felt::Felt;
 
     let syncing_status = SyncingStatus::<Felt>::NotSyncing;
     let s = serde_json::to_string(&syncing_status).unwrap();
@@ -92,7 +92,7 @@ fn syncing_status_to_false() {
 #[cfg(test)]
 #[test]
 fn syncing_status_from_true() {
-    use crate::Felt;
+    pub use starknet_types_core::felt::Felt;
     let s = "true";
     assert!(serde_json::from_str::<SyncingStatus<Felt>>(s).is_err());
 }
diff --git a/crates/starknet-types-rpc/src/lib.rs b/crates/starknet-types-rpc/src/lib.rs
index 75a1d6e1..dfb4ddcd 100644
--- a/crates/starknet-types-rpc/src/lib.rs
+++ b/crates/starknet-types-rpc/src/lib.rs
@@ -17,6 +17,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 extern crate alloc;
+extern crate core;
 
 mod custom;
 mod custom_serde;
diff --git a/crates/starknet-types-rpc/src/v0_7_1/mod.rs b/crates/starknet-types-rpc/src/v0_7_1/mod.rs
index 708fae19..2df2c821 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/mod.rs
+++ b/crates/starknet-types-rpc/src/v0_7_1/mod.rs
@@ -1,7 +1,4 @@
 //! v0.7.1 of the API.
-
-pub use starknet_types_core::felt::Felt;
-
 pub use crate::custom::{
     BlockId, BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn,
     SyncingStatus,
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.rs b/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.rs
index 39256771..50050541 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.rs
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.rs
@@ -1,23 +1,30 @@
 //
-// This file was automatically generated by openrpc-gen first, then manually edited.
+// This file was automatically generated by openrpc-gen.
+//
+// Do not edit it manually and instead edit either the source OpenRPC document,
+// the configuration file, or open an issue or pull request on the openrpc-gen
+// GitHub repository.
+//
+//     https://github.com/nils-mathieu/openrpc-gen
+//
 
 use super::{BlockId, BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn};
 use crate::custom_serde::NumAsHex;
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::marker::PhantomData;
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Serialize};
+use std::marker::PhantomData;
 
 pub type Address<F> = F;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TransactionAndReceipt<F> {
     pub receipt: TxnReceipt<F>,
     pub transaction: Txn<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TxnWithHash<F> {
     #[serde(flatten)]
     pub transaction: Txn<F>,
@@ -26,7 +33,7 @@ pub struct TxnWithHash<F> {
 
 pub type BlockHash<F> = F;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BlockHeader<F> {
     pub block_hash: BlockHash<F>,
     /// The block number (its height)
@@ -53,7 +60,7 @@ pub struct BlockHeader<F> {
 pub type BlockNumber = u64;
 
 /// The status of the block
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum BlockStatus {
     #[serde(rename = "ACCEPTED_ON_L1")]
     AcceptedOnL1,
@@ -66,7 +73,7 @@ pub enum BlockStatus {
 }
 
 /// A tag specifying a dynamic reference to a block
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum BlockTag {
     #[serde(rename = "latest")]
     Latest,
@@ -75,7 +82,7 @@ pub enum BlockTag {
 }
 
 /// The block object
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BlockWithReceipts<F> {
     /// The transactions in this block
     pub transactions: Vec<TransactionAndReceipt<F>>,
@@ -85,7 +92,7 @@ pub struct BlockWithReceipts<F> {
 }
 
 /// The block object
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BlockWithTxs<F> {
     /// The transactions in this block
     pub transactions: Vec<TxnWithHash<F>>,
@@ -95,7 +102,7 @@ pub struct BlockWithTxs<F> {
 }
 
 /// The block object
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BlockWithTxHashes<F> {
     /// The hashes of the transactions included in this block
     pub transactions: Vec<TxnHash<F>>,
@@ -104,7 +111,7 @@ pub struct BlockWithTxHashes<F> {
     pub block_header: BlockHeader<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BroadcastedDeclareTxnV1<F: Default> {
     /// The class to be declared
     pub contract_class: DeprecatedContractClass<F>,
@@ -116,8 +123,8 @@ pub struct BroadcastedDeclareTxnV1<F: Default> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub struct BroadcastedDeclareTxnV2<F> {
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct BroadcastedDeclareTxnV2<F: Default> {
     /// The hash of the Cairo assembly resulting from the Sierra compilation
     pub compiled_class_hash: F,
     /// The class to be declared
@@ -130,7 +137,42 @@ pub struct BroadcastedDeclareTxnV2<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct BroadcastedDeclareTxnV3<F: Default> {
+    /// data needed to deploy the account contract from which this tx will be initiated
+    pub account_deployment_data: Vec<F>,
+    /// The hash of the Cairo assembly resulting from the Sierra compilation
+    pub compiled_class_hash: F,
+    /// The class to be declared
+    pub contract_class: ContractClass<F>,
+    /// The storage domain of the account's balance from which fee will be charged
+    pub fee_data_availability_mode: DaMode,
+    pub nonce: F,
+    /// The storage domain of the account's nonce (an account has a nonce per DA mode)
+    pub nonce_data_availability_mode: DaMode,
+    /// data needed to allow the paymaster to pay for the transaction in native tokens
+    pub paymaster_data: Vec<F>,
+    /// resource bounds for the transaction execution
+    pub resource_bounds: ResourceBoundsMapping,
+    /// The address of the account contract sending the declaration transaction
+    pub sender_address: Address<F>,
+    pub signature: Signature<F>,
+    /// the tip for the transaction
+    pub tip: U64,
+    /// Version of the transaction scheme
+    pub version: Version,
+}
+
+/// Version of the transaction scheme
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
+pub enum Version {
+    #[serde(rename = "0x100000000000000000000000000000003")]
+    X100000000000000000000000000000003,
+    #[serde(rename = "0x3")]
+    X3,
+}
+
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum BroadcastedTxn<F: Default> {
     #[serde(rename = "INVOKE")]
@@ -144,7 +186,7 @@ pub enum BroadcastedTxn<F: Default> {
 /// StarkNet chain id, given in hex representation.
 pub type ChainId = u64;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct CommonReceiptProperties<F> {
     /// The fee that was charged by the sequencer
     pub actual_fee: FeePayment<F>,
@@ -161,7 +203,7 @@ pub struct CommonReceiptProperties<F> {
     pub anon: Anonymous,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum Anonymous {
     /// Common properties for a transaction receipt that was executed successfully
@@ -171,14 +213,14 @@ pub enum Anonymous {
 }
 
 /// Common properties for a transaction receipt that was executed successfully
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct SuccessfulCommonReceiptProperties {
     /// The execution status of the transaction
     pub execution_status: String, /* SUCCEEDED */
 }
 
 /// Common properties for a transaction receipt that was reverted
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct RevertedCommonReceiptProperties {
     /// The execution status of the transaction
     pub execution_status: String, /* REVERTED */
@@ -187,7 +229,7 @@ pub struct RevertedCommonReceiptProperties {
 }
 
 /// The resources consumed by the VM
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ComputationResources {
     /// the number of BITWISE builtin instances
     #[serde(default)]
@@ -222,7 +264,7 @@ pub struct ComputationResources {
 
 pub type ContractAbi = Vec<ContractAbiEntry>;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ContractAbiEntry {
     Function(FunctionAbiEntry),
@@ -230,7 +272,7 @@ pub enum ContractAbiEntry {
     Struct(StructAbiEntry),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ContractClass<F> {
     /// The class ABI, as supplied by the user declaring the class
     #[serde(default)]
@@ -242,7 +284,7 @@ pub struct ContractClass<F> {
     pub sierra_program: Vec<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EntryPointsByType<F> {
     #[serde(rename = "CONSTRUCTOR")]
     pub constructor: Vec<SierraEntryPoint<F>>,
@@ -252,7 +294,7 @@ pub struct EntryPointsByType<F> {
     pub l1_handler: Vec<SierraEntryPoint<F>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ContractStorageDiffItem<F: Default> {
     /// The contract address for which the storage changed
     pub address: F,
@@ -260,7 +302,7 @@ pub struct ContractStorageDiffItem<F: Default> {
     pub storage_entries: Vec<KeyValuePair<F>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct KeyValuePair<F> {
     /// The key of the changed value
     #[serde(default)]
@@ -271,13 +313,13 @@ pub struct KeyValuePair<F> {
 }
 
 /// Specifies a storage domain in Starknet. Each domain has different gurantess regarding availability
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum DaMode {
     L1,
     L2,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "version")]
 pub enum DeclareTxn<F> {
     #[serde(rename = "0x0")]
@@ -290,13 +332,13 @@ pub enum DeclareTxn<F> {
     V3(DeclareTxnV3<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTxnReceipt<F> {
     #[serde(flatten)]
     pub common_receipt_properties: CommonReceiptProperties<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTxnV0<F> {
     /// The hash of the declared class
     pub class_hash: F,
@@ -307,7 +349,7 @@ pub struct DeclareTxnV0<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTxnV1<F> {
     /// The hash of the declared class
     pub class_hash: F,
@@ -319,7 +361,7 @@ pub struct DeclareTxnV1<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTxnV2<F> {
     /// The hash of the declared class
     pub class_hash: F,
@@ -333,7 +375,7 @@ pub struct DeclareTxnV2<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTxnV3<F> {
     /// data needed to deploy the account contract from which this tx will be initiated
     pub account_deployment_data: Vec<F>,
@@ -357,7 +399,7 @@ pub struct DeclareTxnV3<F> {
     pub tip: U64,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployedContractItem<F> {
     /// The address of the contract
     pub address: F,
@@ -366,7 +408,7 @@ pub struct DeployedContractItem<F> {
 }
 
 /// deploys a new account contract
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "version")]
 pub enum DeployAccountTxn<F> {
     #[serde(rename = "0x1")]
@@ -375,7 +417,7 @@ pub enum DeployAccountTxn<F> {
     V3(DeployAccountTxnV3<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployAccountTxnReceipt<F> {
     #[serde(flatten)]
     pub common_receipt_properties: CommonReceiptProperties<F>,
@@ -384,7 +426,7 @@ pub struct DeployAccountTxnReceipt<F> {
 }
 
 /// Deploys an account contract, charges fee from the pre-funded account addresses
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployAccountTxnV1<F> {
     /// The hash of the deployed contract's class
     pub class_hash: F,
@@ -399,7 +441,7 @@ pub struct DeployAccountTxnV1<F> {
 }
 
 /// Deploys an account contract, charges fee from the pre-funded account addresses
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployAccountTxnV3<F> {
     /// The hash of the deployed contract's class
     pub class_hash: F,
@@ -421,7 +463,7 @@ pub struct DeployAccountTxnV3<F> {
     pub tip: U64,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployTxn<F> {
     /// The hash of the deployed contract's class
     pub class_hash: F,
@@ -433,7 +475,7 @@ pub struct DeployTxn<F> {
     pub version: F,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployTxnReceipt<F> {
     #[serde(flatten)]
     pub common_receipt_properties: CommonReceiptProperties<F>,
@@ -441,7 +483,7 @@ pub struct DeployTxnReceipt<F> {
     pub contract_address: F,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeprecatedCairoEntryPoint<F> {
     /// The offset of the entry point in the program
     #[serde(with = "NumAsHex")]
@@ -451,7 +493,7 @@ pub struct DeprecatedCairoEntryPoint<F> {
 }
 
 /// The definition of a StarkNet contract class
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeprecatedContractClass<F: Default> {
     #[serde(default)]
     pub abi: Option<ContractAbi>,
@@ -460,7 +502,7 @@ pub struct DeprecatedContractClass<F: Default> {
     pub program: String,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeprecatedEntryPointsByType<F> {
     #[serde(default)]
     #[serde(rename = "CONSTRUCTOR")]
@@ -474,7 +516,7 @@ pub struct DeprecatedEntryPointsByType<F> {
 }
 
 /// Event information decorated with metadata on where it was emitted / An event emitted as a result of transaction execution
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EmittedEvent<F> {
     /// The event information
     #[serde(flatten)]
@@ -493,14 +535,14 @@ pub struct EmittedEvent<F> {
 pub type EthAddress = String;
 
 /// A StarkNet event
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct Event<F> {
     pub from_address: Address<F>,
     pub data: Vec<F>,
     pub keys: Vec<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EventsChunk<F: Default> {
     /// Use this token in a subsequent query to obtain the next page. Should not appear if there are no more pages.
     #[serde(default)]
@@ -508,7 +550,7 @@ pub struct EventsChunk<F: Default> {
     pub events: Vec<EmittedEvent<F>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct EventAbiEntry {
     pub data: Vec<TypedParameter>,
     pub keys: Vec<TypedParameter>,
@@ -521,7 +563,7 @@ pub struct EventAbiEntry {
 pub type EventAbiType = String;
 
 /// the resources consumed by the transaction, includes both computation and data
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ExecutionResources {
     /// the number of BITWISE builtin instances
     #[serde(default)]
@@ -555,7 +597,7 @@ pub struct ExecutionResources {
     pub data_availability: DataAvailability,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DataAvailability {
     /// the data gas consumed by this transaction's data, 0 if it uses gas for DA
     pub l1_data_gas: u64,
@@ -563,7 +605,7 @@ pub struct DataAvailability {
     pub l1_gas: u64,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct FeeEstimate<F> {
     /// The Ethereum data gas consumption of the transaction
     pub data_gas_consumed: F,
@@ -580,7 +622,7 @@ pub struct FeeEstimate<F> {
 }
 
 /// fee payment info as it appears in receipts
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct FeePayment<F> {
     /// amount paid
     pub amount: F,
@@ -588,7 +630,7 @@ pub struct FeePayment<F> {
     pub unit: PriceUnit,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct FunctionAbiEntry {
     pub inputs: Vec<TypedParameter>,
     /// The function name
@@ -601,7 +643,7 @@ pub struct FunctionAbiEntry {
     pub ty: FunctionAbiType,
 }
 
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum FunctionAbiType {
     #[serde(rename = "constructor")]
     Constructor,
@@ -612,7 +654,7 @@ pub enum FunctionAbiType {
 }
 
 /// Function call information
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct FunctionCall<F> {
     /// The parameters passed to the function
     pub calldata: Vec<F>,
@@ -623,7 +665,7 @@ pub struct FunctionCall<F> {
 pub type FunctionStateMutability = String;
 
 /// Initiate a transaction from an account
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "version")]
 pub enum InvokeTxn<F> {
     #[serde(rename = "0x0")]
@@ -634,14 +676,14 @@ pub enum InvokeTxn<F> {
     V3(InvokeTxnV3<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct InvokeTxnReceipt<F> {
     #[serde(flatten)]
     pub common_receipt_properties: CommonReceiptProperties<F>,
 }
 
 /// invokes a specific function in the desired contract (not necessarily an account)
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct InvokeTxnV0<F> {
     /// The parameters passed to the function
     pub calldata: Vec<F>,
@@ -652,7 +694,7 @@ pub struct InvokeTxnV0<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct InvokeTxnV1<F> {
     /// The data expected by the account's `execute` function (in most usecases, this includes the called contract address and a function selector)
     pub calldata: Vec<F>,
@@ -663,7 +705,7 @@ pub struct InvokeTxnV1<F> {
     pub signature: Signature<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct InvokeTxnV3<F> {
     /// data needed to deploy the account contract from which this tx will be initiated
     pub account_deployment_data: Vec<F>,
@@ -684,7 +726,7 @@ pub struct InvokeTxnV3<F> {
     pub tip: U64,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct L1HandlerTxn<F> {
     /// The L1->L2 message nonce field of the SN Core L1 contract at the time the transaction was sent
     #[serde(with = "NumAsHex")]
@@ -696,7 +738,7 @@ pub struct L1HandlerTxn<F> {
 }
 
 /// receipt for l1 handler transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct L1HandlerTxnReceipt<F> {
     /// The message hash as it appears on the L1 core contract
     #[serde(with = "NumAsHex")]
@@ -705,7 +747,7 @@ pub struct L1HandlerTxnReceipt<F> {
     pub common_receipt_properties: CommonReceiptProperties<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct MsgFromL1<F> {
     /// The selector of the l1_handler in invoke in the target contract
     pub entry_point_selector: F,
@@ -717,7 +759,7 @@ pub struct MsgFromL1<F> {
     pub to_address: Address<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct MsgToL1<F> {
     /// The address of the L2 contract sending the message
     pub from_address: F,
@@ -727,7 +769,7 @@ pub struct MsgToL1<F> {
     pub to_address: F,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct PendingBlockHeader<F> {
     /// specifies whether the data of this block is published via blob data or calldata
     pub l1_da_mode: L1DaMode,
@@ -746,7 +788,7 @@ pub struct PendingBlockHeader<F> {
 }
 
 /// specifies whether the data of this block is published via blob data or calldata
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum L1DaMode {
     #[serde(rename = "BLOB")]
     Blob,
@@ -755,7 +797,7 @@ pub enum L1DaMode {
 }
 
 /// The dynamic block being constructed by the sequencer. Note that this object will be deprecated upon decentralization.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct PendingBlockWithReceipts<F> {
     /// The transactions in this block
     pub transactions: Vec<TransactionAndReceipt<F>>,
@@ -764,7 +806,7 @@ pub struct PendingBlockWithReceipts<F> {
 }
 
 /// The dynamic block being constructed by the sequencer. Note that this object will be deprecated upon decentralization.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct PendingBlockWithTxs<F> {
     /// The transactions in this block
     pub transactions: Vec<TxnWithHash<F>>,
@@ -773,7 +815,7 @@ pub struct PendingBlockWithTxs<F> {
 }
 
 /// The dynamic block being constructed by the sequencer. Note that this object will be deprecated upon decentralization.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct PendingBlockWithTxHashes<F> {
     /// The hashes of the transactions included in this block
     pub transactions: Vec<TxnHash<F>>,
@@ -782,14 +824,14 @@ pub struct PendingBlockWithTxHashes<F> {
 }
 
 /// Pending state update
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct PendingStateUpdate<F: Default> {
     /// The previous global state root
     pub old_root: F,
     pub state_diff: StateDiff<F>,
 }
 
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum PriceUnit {
     #[serde(rename = "FRI")]
     Fri,
@@ -797,7 +839,7 @@ pub enum PriceUnit {
     Wei,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ResourceBounds {
     /// the max amount of the resource that can be used in the tx
     pub max_amount: U64,
@@ -805,7 +847,7 @@ pub struct ResourceBounds {
     pub max_price_per_unit: U128,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ResourceBoundsMapping {
     /// The max amount and max price per unit of L1 gas used in this tx
     pub l1_gas: ResourceBounds,
@@ -813,7 +855,7 @@ pub struct ResourceBoundsMapping {
     pub l2_gas: ResourceBounds,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ResourcePrice<F> {
     /// the price of one unit of the given resource, denominated in fri (10^-18 strk)
     pub price_in_fri: F,
@@ -821,7 +863,7 @@ pub struct ResourcePrice<F> {
     pub price_in_wei: F,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct SierraEntryPoint<F> {
     /// The index of the function in the program
     pub function_idx: u64,
@@ -836,7 +878,7 @@ pub type Signature<F> = Vec<F>;
 pub type SimulationFlagForEstimateFee = String;
 
 /// 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, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct StateDiff<F: Default> {
     pub declared_classes: Vec<NewClasses<F>>,
     pub deployed_contracts: Vec<DeployedContractItem<F>>,
@@ -847,7 +889,7 @@ pub struct StateDiff<F: Default> {
 }
 
 /// The declared class hash and compiled class hash
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct NewClasses<F> {
     /// The hash of the declared class
     #[serde(default)]
@@ -858,7 +900,7 @@ pub struct NewClasses<F> {
 }
 
 /// The updated nonce per contract address
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct NonceUpdate<F> {
     /// The address of the contract
     #[serde(default)]
@@ -869,7 +911,7 @@ pub struct NonceUpdate<F> {
 }
 
 /// The list of contracts whose class was replaced
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ReplacedClass<F> {
     /// The new class hash
     #[serde(default)]
@@ -879,7 +921,7 @@ pub struct ReplacedClass<F> {
     pub contract_address: Option<Address<F>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct StateUpdate<F: Default> {
     pub block_hash: BlockHash<F>,
     /// The new global state root
@@ -892,7 +934,7 @@ pub struct StateUpdate<F: Default> {
 /// A storage key. Represented as up to 62 hex digits, 3 bits, and 5 leading zeroes.
 pub type StorageKey = String;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct StructAbiEntry {
     pub members: Vec<StructMember>,
     /// The struct name
@@ -904,7 +946,7 @@ pub struct StructAbiEntry {
 
 pub type StructAbiType = String;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct StructMember {
     #[serde(flatten)]
     pub typed_parameter: TypedParameter,
@@ -914,7 +956,7 @@ pub struct StructMember {
 }
 
 /// An object describing the node synchronization status
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct SyncStatus<F> {
     /// The hash of the current block being synchronized
     pub current_block_hash: BlockHash<F>,
@@ -931,7 +973,7 @@ pub struct SyncStatus<F> {
 }
 
 /// The transaction schema, as it appears inside a block
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum Txn<F> {
     #[serde(rename = "INVOKE")]
@@ -947,7 +989,7 @@ pub enum Txn<F> {
 }
 
 /// The execution status of the transaction
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum TxnExecutionStatus {
     #[serde(rename = "REVERTED")]
     Reverted,
@@ -956,7 +998,7 @@ pub enum TxnExecutionStatus {
 }
 
 /// The finality status of the transaction
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum TxnFinalityStatus {
     #[serde(rename = "ACCEPTED_ON_L1")]
     L1,
@@ -965,10 +1007,9 @@ pub enum TxnFinalityStatus {
 }
 
 /// The transaction hash, as assigned in StarkNet
-// pub type TxnHash<F: Serialize + for<'de> Deserialize<'de>> = F;
 pub type TxnHash<F> = F;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum TxnReceipt<F> {
     #[serde(rename = "INVOKE")]
@@ -983,7 +1024,7 @@ pub enum TxnReceipt<F> {
     DeployAccount(DeployAccountTxnReceipt<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TxnReceiptWithBlockInfo<F> {
     #[serde(flatten)]
     pub transaction_receipt: TxnReceipt<F>,
@@ -996,7 +1037,7 @@ pub struct TxnReceiptWithBlockInfo<F> {
 }
 
 /// The finality status of the transaction, including the case the txn is still in the mempool or failed validation during the block construction phase
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum TxnStatus {
     #[serde(rename = "ACCEPTED_ON_L1")]
     AcceptedOnL1,
@@ -1008,7 +1049,7 @@ pub enum TxnStatus {
     Rejected,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TypedParameter {
     /// The parameter's name
     pub name: String,
@@ -1023,42 +1064,42 @@ pub type U128 = String;
 /// 64 bit integers, represented by hex string of length at most 16
 pub type U64 = String;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct BlockHashAndNumber<F> {
     pub block_hash: BlockHash<F>,
     pub block_number: BlockNumber,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum StarknetGetBlockWithTxsAndReceiptsResult<F> {
     Block(BlockWithReceipts<F>),
     Pending(PendingBlockWithReceipts<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum MaybePendingBlockWithTxHashes<F> {
     Block(BlockWithTxHashes<F>),
     Pending(PendingBlockWithTxHashes<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum MaybePendingBlockWithTxs<F> {
     Block(BlockWithTxs<F>),
     Pending(PendingBlockWithTxs<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum MaybeDeprecatedContractClass<F: Default> {
     Deprecated(DeprecatedContractClass<F>),
     ContractClass(ContractClass<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub struct EventFilterWithPageRequest<F: Copy> {
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub struct EventFilterWithPageRequest<F> {
     #[serde(default)]
     pub address: Option<Address<F>>,
     #[serde(default)]
@@ -1074,14 +1115,14 @@ pub struct EventFilterWithPageRequest<F: Copy> {
     pub continuation_token: Option<String>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum MaybePendingStateUpdate<F: Default> {
     Block(StateUpdate<F>),
     Pending(PendingStateUpdate<F>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TxnFinalityAndExecutionStatus {
     #[serde(default)]
     pub execution_status: Option<TxnExecutionStatus>,
@@ -1158,7 +1199,7 @@ pub struct GetBlockWithTxHashesParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetBlockWithTxHashesParams<F> {
+impl<F: Serialize> Serialize for GetBlockWithTxHashesParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1170,7 +1211,7 @@ impl<F: Copy + Serialize> Serialize for GetBlockWithTxHashesParams<F> {
     }
 }
 
-impl<'de, F: Serialize + Deserialize<'de>> Deserialize<'de> for GetBlockWithTxHashesParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetBlockWithTxHashesParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1179,7 +1220,7 @@ impl<'de, F: Serialize + Deserialize<'de>> Deserialize<'de> for GetBlockWithTxHa
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetBlockWithTxHashesParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1237,7 +1278,7 @@ pub struct GetBlockWithTxsParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetBlockWithTxsParams<F> {
+impl<F: Serialize> Serialize for GetBlockWithTxsParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1249,7 +1290,7 @@ impl<F: Copy + Serialize> Serialize for GetBlockWithTxsParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetBlockWithTxsParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetBlockWithTxsParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1258,7 +1299,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetBlockW
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetBlockWithTxsParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1316,7 +1357,7 @@ pub struct GetBlockWithReceiptsParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetBlockWithReceiptsParams<F> {
+impl<F: Serialize> Serialize for GetBlockWithReceiptsParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1328,7 +1369,7 @@ impl<F: Copy + Serialize> Serialize for GetBlockWithReceiptsParams<F> {
     }
 }
 
-impl<'de, F: Copy + Deserialize<'de>> Deserialize<'de> for GetBlockWithReceiptsParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetBlockWithReceiptsParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1337,7 +1378,7 @@ impl<'de, F: Copy + Deserialize<'de>> Deserialize<'de> for GetBlockWithReceiptsP
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetBlockWithReceiptsParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1395,7 +1436,7 @@ pub struct GetStateUpdateParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetStateUpdateParams<F> {
+impl<F: Serialize> Serialize for GetStateUpdateParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1407,7 +1448,7 @@ impl<F: Copy + Serialize> Serialize for GetStateUpdateParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetStateUpdateParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetStateUpdateParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1416,7 +1457,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetStateU
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetStateUpdateParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1478,7 +1519,7 @@ pub struct GetStorageAtParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetStorageAtParams<F> {
+impl<F: Serialize> Serialize for GetStorageAtParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1492,7 +1533,7 @@ impl<F: Copy + Serialize> Serialize for GetStorageAtParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetStorageAtParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetStorageAtParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1501,7 +1542,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetStorag
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetStorageAtParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1695,7 +1736,7 @@ pub struct GetTransactionByBlockIdAndIndexParams<F> {
     pub index: u64,
 }
 
-impl<F: Copy + Serialize> Serialize for GetTransactionByBlockIdAndIndexParams<F> {
+impl<F: Serialize> Serialize for GetTransactionByBlockIdAndIndexParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1708,9 +1749,7 @@ impl<F: Copy + Serialize> Serialize for GetTransactionByBlockIdAndIndexParams<F>
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de>
-    for GetTransactionByBlockIdAndIndexParams<F>
-{
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetTransactionByBlockIdAndIndexParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1719,7 +1758,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de>
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetTransactionByBlockIdAndIndexParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1847,7 +1886,7 @@ pub struct GetClassParams<F> {
     pub class_hash: F,
 }
 
-impl<F: Copy + Serialize> Serialize for GetClassParams<F> {
+impl<F: Serialize> Serialize for GetClassParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1860,7 +1899,7 @@ impl<F: Copy + Serialize> Serialize for GetClassParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetClassParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1869,7 +1908,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassP
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetClassParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -1937,7 +1976,7 @@ pub struct GetClassHashAtParams<F> {
     pub contract_address: Address<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetClassHashAtParams<F> {
+impl<F: Serialize> Serialize for GetClassHashAtParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -1950,7 +1989,7 @@ impl<F: Copy + Serialize> Serialize for GetClassHashAtParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassHashAtParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetClassHashAtParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -1959,7 +1998,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassH
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetClassHashAtParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2027,7 +2066,7 @@ pub struct GetClassAtParams<F> {
     pub contract_address: Address<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetClassAtParams<F> {
+impl<F: Serialize> Serialize for GetClassAtParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2040,7 +2079,7 @@ impl<F: Copy + Serialize> Serialize for GetClassAtParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassAtParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetClassAtParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2049,7 +2088,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetClassA
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetClassAtParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2115,7 +2154,7 @@ pub struct GetBlockTransactionCountParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetBlockTransactionCountParams<F> {
+impl<F: Serialize> Serialize for GetBlockTransactionCountParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2127,9 +2166,7 @@ impl<F: Copy + Serialize> Serialize for GetBlockTransactionCountParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de>
-    for GetBlockTransactionCountParams<F>
-{
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetBlockTransactionCountParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2138,7 +2175,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de>
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetBlockTransactionCountParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2198,7 +2235,7 @@ pub struct CallParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for CallParams<F> {
+impl<F: Serialize> Serialize for CallParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2211,7 +2248,7 @@ impl<F: Copy + Serialize> Serialize for CallParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for CallParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for CallParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2220,7 +2257,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for CallParam
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = CallParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2287,7 +2324,7 @@ pub struct EstimateFeeParams<F: Default> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Default + Serialize> Serialize for EstimateFeeParams<F> {
+impl<F: Default + Serialize> Serialize for EstimateFeeParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2301,9 +2338,7 @@ impl<F: Copy + Default + Serialize> Serialize for EstimateFeeParams<F> {
     }
 }
 
-impl<'de, F: Copy + Default + Serialize + Deserialize<'de>> Deserialize<'de>
-    for EstimateFeeParams<F>
-{
+impl<'de, F: Default + Deserialize<'de>> Deserialize<'de> for EstimateFeeParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2312,7 +2347,7 @@ impl<'de, F: Copy + Default + Serialize + Deserialize<'de>> Deserialize<'de>
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Default + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = EstimateFeeParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2386,7 +2421,7 @@ pub struct EstimateMessageFeeParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for EstimateMessageFeeParams<F> {
+impl<F: Serialize> Serialize for EstimateMessageFeeParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2399,7 +2434,7 @@ impl<F: Copy + Serialize> Serialize for EstimateMessageFeeParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for EstimateMessageFeeParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for EstimateMessageFeeParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2408,7 +2443,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for EstimateM
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = EstimateMessageFeeParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2718,12 +2753,12 @@ impl<'de> Deserialize<'de> for SyncingParams {
 
 /// Parameters of the `starknet_getEvents` method.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct GetEventsParams<F: Copy> {
+pub struct GetEventsParams<F: Default> {
     /// The conditions used to filter the returned events
     pub filter: EventFilterWithPageRequest<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetEventsParams<F> {
+impl<F: Default + Serialize> Serialize for GetEventsParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2735,7 +2770,7 @@ impl<F: Copy + Serialize> Serialize for GetEventsParams<F> {
     }
 }
 
-impl<'de, F: Copy + Default + Deserialize<'de>> Deserialize<'de> for GetEventsParams<F> {
+impl<'de, F: Default + Deserialize<'de>> Deserialize<'de> for GetEventsParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2744,7 +2779,7 @@ impl<'de, F: Copy + Default + Deserialize<'de>> Deserialize<'de> for GetEventsPa
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetEventsParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -2776,7 +2811,7 @@ impl<'de, F: Copy + Default + Deserialize<'de>> Deserialize<'de> for GetEventsPa
                 A: serde::de::MapAccess<'de>,
             {
                 #[derive(Deserialize)]
-                struct Helper<F: Copy + Default> {
+                struct Helper<F: Default> {
                     filter: EventFilterWithPageRequest<F>,
                 }
 
@@ -2804,7 +2839,7 @@ pub struct GetNonceParams<F> {
     pub contract_address: Address<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for GetNonceParams<F> {
+impl<F: Serialize> Serialize for GetNonceParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -2817,7 +2852,7 @@ impl<F: Copy + Serialize> Serialize for GetNonceParams<F> {
     }
 }
 
-impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetNonceParams<F> {
+impl<'de, F: Deserialize<'de>> Deserialize<'de> for GetNonceParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -2826,7 +2861,7 @@ impl<'de, F: Copy + Serialize + Deserialize<'de>> Deserialize<'de> for GetNonceP
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Serialize + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = GetNonceParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.toml b/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.toml
index 4af9cc5c..e7e4c971 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.toml
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_api_openrpc.toml
@@ -4,9 +4,10 @@ run-rustfmt = true
 [generation]
 additional-imports = [
     "crate::custom_serde::NumAsHex",
-    "super::{BlockId, Felt, BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn}",
+    "super::{BlockId, BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn}",
     "alloc::vec::Vec",
     "alloc::string::String",
+    "std::marker::PhantomData"
 ]
 method-name-prefix = "starknet_"
 param-types = true
@@ -23,6 +24,7 @@ preserve = [
     "#/components/schemas/SYNC_STATUS",
     "#/components/schemas/BROADCASTED_DECLARE_TXN_V1",
     "#/components/schemas/BROADCASTED_DECLARE_TXN_V2",
+    "#/components/schemas/BROADCASTED_DECLARE_TXN_V3",
     "#/components/schemas/COMPUTATION_RESOURCES",
 ]
 
@@ -30,7 +32,7 @@ preserve = [
 # Too tricky to automatically fix cleanly
 "#/components/schemas/BLOCK_ID" = "BlockId"
 "#/methods/starknet_syncing/result/_anon" = "SyncingStatus"
-"#/components/schemas/FELT" = "Felt"
+"#/components/schemas/FELT" = "F"
 
 # Query-only types
 "#/components/schemas/BROADCASTED_DECLARE_TXN" = "BroadcastedDeclareTxn"
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.rs b/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.rs
index a360ec02..23948364 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.rs
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.rs
@@ -1,5 +1,12 @@
 //
-// This file was automatically generated by openrpc-gen first, then manually edited.
+// This file was automatically generated by openrpc-gen.
+//
+// Do not edit it manually and instead edit either the source OpenRPC document,
+// the configuration file, or open an issue or pull request on the openrpc-gen
+// GitHub repository.
+//
+//     https://github.com/nils-mathieu/openrpc-gen
+//
 
 use super::{
     BlockId, BroadcastedTxn, ComputationResources, Event, ExecutionResources, FeeEstimate,
@@ -9,8 +16,9 @@ use alloc::string::String;
 use alloc::vec::Vec;
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Serialize};
+use std::marker::PhantomData;
 
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum CallType {
     #[serde(rename = "CALL")]
     Regular,
@@ -20,7 +28,7 @@ pub enum CallType {
     LibraryCall,
 }
 
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum EntryPointType {
     #[serde(rename = "CONSTRUCTOR")]
     Constructor,
@@ -30,7 +38,7 @@ pub enum EntryPointType {
     L1Handler,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct FunctionInvocation<F> {
     #[serde(flatten)]
     pub function_call: FunctionCall<F>,
@@ -55,7 +63,7 @@ pub struct FunctionInvocation<F> {
 pub type NestedCall<F> = FunctionInvocation<F>;
 
 /// an event alongside its order within the transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct OrderedEvent<F> {
     /// the order of the event within the transaction
     #[serde(default)]
@@ -65,7 +73,7 @@ pub struct OrderedEvent<F> {
 }
 
 /// a message alongside its order within the transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct OrderedMessage<F> {
     /// the order of the message within the transaction
     #[serde(default)]
@@ -75,7 +83,7 @@ pub struct OrderedMessage<F> {
 }
 
 /// Flags that indicate how to simulate a given transaction. By default, the sequencer behavior is replicated locally (enough funds are expected to be in the account, and fee will be deducted from the balance before the simulation of the next transaction). To skip the fee charge, use the SKIP_FEE_CHARGE flag.
-#[derive(Serialize, Deserialize, Copy, PartialEq, Eq, Hash, Clone, Debug)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 pub enum SimulationFlag {
     #[serde(rename = "SKIP_FEE_CHARGE")]
     FeeCharge,
@@ -83,7 +91,7 @@ pub enum SimulationFlag {
     Validate,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum TransactionTrace<F: Default> {
     /// the execution trace of an invoke transaction
@@ -101,7 +109,7 @@ pub enum TransactionTrace<F: Default> {
 }
 
 /// the execution trace of an invoke transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct InvokeTransactionTrace<F: Default> {
     /// the trace of the __execute__ call or constructor call, depending on the transaction type (none for declare transactions)
     pub execute_invocation: ExecuteInvocation<F>,
@@ -117,21 +125,21 @@ pub struct InvokeTransactionTrace<F: Default> {
 }
 
 /// the trace of the __execute__ call or constructor call, depending on the transaction type (none for declare transactions)
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Eq, Hash, PartialEq, Serialize, Deserialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ExecuteInvocation<F> {
     FunctionInvocation(FunctionInvocation<F>),
     Anon(RevertedInvocation),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct RevertedInvocation {
     /// the revert reason for the failed execution
     pub revert_reason: String,
 }
 
 /// the execution trace of a declare transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeclareTransactionTrace<F: Default> {
     /// the resources consumed by the transaction, includes both computation and data
     pub execution_resources: ExecutionResources,
@@ -145,7 +153,7 @@ pub struct DeclareTransactionTrace<F: Default> {
 }
 
 /// the execution trace of a deploy account transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct DeployAccountTransactionTrace<F: Default> {
     /// the trace of the __execute__ call or constructor call, depending on the transaction type (none for declare transactions)
     pub constructor_invocation: FunctionInvocation<F>,
@@ -161,7 +169,7 @@ pub struct DeployAccountTransactionTrace<F: Default> {
 }
 
 /// the execution trace of an L1 handler transaction
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct L1HandlerTransactionTrace<F: Default> {
     /// the resources consumed by the transaction, includes both computation and data
     pub execution_resources: ExecutionResources,
@@ -172,7 +180,7 @@ pub struct L1HandlerTransactionTrace<F: Default> {
     pub state_diff: Option<StateDiff<F>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct SimulateTransactionsResult<F: Default> {
     #[serde(default)]
     pub fee_estimation: Option<FeeEstimate<F>>,
@@ -181,7 +189,7 @@ pub struct SimulateTransactionsResult<F: Default> {
 }
 
 /// A single pair of transaction hash and corresponding trace
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct TraceBlockTransactionsResult<F: Default> {
     #[serde(default)]
     pub trace_root: Option<TransactionTrace<F>>,
@@ -214,7 +222,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for TraceTransactionParams<F> {
         D: serde::Deserializer<'de>,
     {
         struct Visitor<F> {
-            marker: core::marker::PhantomData<F>,
+            marker: PhantomData<F>,
         }
 
         impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
@@ -263,7 +271,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for TraceTransactionParams<F> {
         }
 
         deserializer.deserialize_any(Visitor::<F> {
-            marker: core::marker::PhantomData,
+            marker: PhantomData,
         })
     }
 }
@@ -279,7 +287,7 @@ pub struct SimulateTransactionsParams<F: Default> {
     pub simulation_flags: Vec<SimulationFlag>,
 }
 
-impl<F: Copy + Default + Serialize> Serialize for SimulateTransactionsParams<F> {
+impl<F: Default + Serialize> Serialize for SimulateTransactionsParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -293,16 +301,16 @@ impl<F: Copy + Default + Serialize> Serialize for SimulateTransactionsParams<F>
     }
 }
 
-impl<'de, F: Copy + Default + Deserialize<'de>> Deserialize<'de> for SimulateTransactionsParams<F> {
+impl<'de, F: Default + Deserialize<'de>> Deserialize<'de> for SimulateTransactionsParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
         struct Visitor<F> {
-            marker: core::marker::PhantomData<F>,
+            marker: PhantomData<F>,
         }
 
-        impl<'de, F: Copy + Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = SimulateTransactionsParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -362,7 +370,7 @@ impl<'de, F: Copy + Default + Deserialize<'de>> Deserialize<'de> for SimulateTra
         }
 
         deserializer.deserialize_any(Visitor::<F> {
-            marker: core::marker::PhantomData,
+            marker: PhantomData,
         })
     }
 }
@@ -374,7 +382,7 @@ pub struct TraceBlockTransactionsParams<F> {
     pub block_id: BlockId<F>,
 }
 
-impl<F: Copy + Serialize> Serialize for TraceBlockTransactionsParams<F> {
+impl<F: Serialize> Serialize for TraceBlockTransactionsParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -392,7 +400,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for TraceBlockTransactionsParams
         D: serde::Deserializer<'de>,
     {
         struct Visitor<F> {
-            marker: core::marker::PhantomData<F>,
+            marker: PhantomData<F>,
         }
 
         impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
@@ -441,7 +449,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for TraceBlockTransactionsParams
         }
 
         deserializer.deserialize_any(Visitor::<F> {
-            marker: core::marker::PhantomData,
+            marker: PhantomData,
         })
     }
 }
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.toml b/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.toml
index c7d82fc6..582891ce 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.toml
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_trace_api_openrpc.toml
@@ -3,9 +3,10 @@ run-rustfmt = true
 
 [generation]
 additional-imports = [
-    "super::{Felt, FunctionCall, Event, MsgToL1, BlockId, FeeEstimate, BroadcastedTxn, StateDiff, TxnHash, ExecutionResources, ComputationResources}",
+    "super::{FunctionCall, Event, MsgToL1, BlockId, FeeEstimate, BroadcastedTxn, StateDiff, TxnHash, ExecutionResources, ComputationResources}",
     "alloc::vec::Vec",
     "alloc::string::String",
+    "std::marker::PhantomData"
 ]
 method-name-prefix = "starknet_"
 param-types = true
@@ -22,7 +23,7 @@ flatten = [
 ]
 
 [fixes.replace]
-"#/components/schemas/FELT" = "Felt"
+"#/components/schemas/FELT" = "F"
 "#/components/schemas/FUNCTION_CALL" = "FunctionCall"
 "#/components/schemas/EVENT" = "Event"
 "#/components/schemas/MSG_TO_L1" = "MsgToL1"
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.rs b/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.rs
index e7d8c35f..cfc40a6a 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.rs
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.rs
@@ -1,38 +1,43 @@
 //
-// This file was automatically generated by openrpc-gen first, then manually edited.
+// This file was automatically generated by openrpc-gen.
+//
+// Do not edit it manually and instead edit either the source OpenRPC document,
+// the configuration file, or open an issue or pull request on the openrpc-gen
+// GitHub repository.
+//
+//     https://github.com/nils-mathieu/openrpc-gen
+//
 
-use super::{
-    BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn, Felt, TxnHash,
-};
-use core::marker::PhantomData;
+use super::{BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn, TxnHash};
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Serialize};
+use std::marker::PhantomData;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ClassAndTxnHash<F> {
     pub class_hash: F,
     pub transaction_hash: TxnHash<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ContractAndTxnHash<F> {
-    pub contract_address: Felt,
+    pub contract_address: F,
     pub transaction_hash: TxnHash<F>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct AddInvokeTransactionResult<F> {
     pub transaction_hash: TxnHash<F>,
 }
 
 /// Parameters of the `starknet_addInvokeTransaction` method.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct AddInvokeTransactionParams<F> {
+pub struct AddInvokeTransactionParams<F: Default> {
     /// The information needed to invoke the function (or account, for version 1 transactions)
     pub invoke_transaction: BroadcastedInvokeTxn<F>,
 }
 
-impl<F: Serialize> Serialize for AddInvokeTransactionParams<F> {
+impl<F: Default + Serialize> Serialize for AddInvokeTransactionParams<F> {
     #[allow(unused_mut)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -44,7 +49,7 @@ impl<F: Serialize> Serialize for AddInvokeTransactionParams<F> {
     }
 }
 
-impl<'de, F: Deserialize<'de>> Deserialize<'de> for AddInvokeTransactionParams<F> {
+impl<'de, F: Default + Deserialize<'de>> Deserialize<'de> for AddInvokeTransactionParams<F> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -53,7 +58,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for AddInvokeTransactionParams<F
             marker: PhantomData<F>,
         }
 
-        impl<'de, F: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
+        impl<'de, F: Default + Deserialize<'de>> serde::de::Visitor<'de> for Visitor<F> {
             type Value = AddInvokeTransactionParams<F>;
 
             fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -85,7 +90,7 @@ impl<'de, F: Deserialize<'de>> Deserialize<'de> for AddInvokeTransactionParams<F
                 A: serde::de::MapAccess<'de>,
             {
                 #[derive(Deserialize)]
-                struct Helper<F> {
+                struct Helper<F: Default> {
                     invoke_transaction: BroadcastedInvokeTxn<F>,
                 }
 
diff --git a/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.toml b/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.toml
index f452d94e..a38e4dc2 100644
--- a/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.toml
+++ b/crates/starknet-types-rpc/src/v0_7_1/starknet_write_api.toml
@@ -3,7 +3,8 @@ run-rustfmt = true
 
 [generation]
 additional-imports = [
-    "super::{BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn, Felt, TxnHash}",
+    "super::{BroadcastedDeclareTxn, BroadcastedDeployAccountTxn, BroadcastedInvokeTxn, TxnHash}",
+    "std::marker::PhantomData"
 ]
 method-name-prefix = "starknet_"
 param-types = true
@@ -21,7 +22,7 @@ strip-enum-variants = true
 "#/components/schemas/BROADCASTED_DEPLOY_ACCOUNT_TXN" = "BroadcastedDeployAccountTxn"
 "#/components/schemas/BROADCASTED_INVOKE_TXN" = "BroadcastedInvokeTxn"
 "#/components/schemas/DECLARE_TXN" = "DeclareTxn"
-"#/components/schemas/FELT" = "Felt"
+"#/components/schemas/FELT" = "F"
 "#/components/schemas/FUNCTION_CALL" = "FunctionCall"
 "#/components/schemas/SIGNATURE" = "Signature"
 "#/components/schemas/TXN_HASH" = "TxnHash"