feat(katana): implement more feeder gateway types (dojoengine#2744)

crates/katana/executor/src/implementation/blockifier/utils.rs

@@ -31,7 +31,7 @@ use katana_cairo::cairo_vm::types::errors::program_errors::ProgramError;
 use katana_cairo::cairo_vm::vm::runners::cairo_runner::ExecutionResources;
 use katana_cairo::starknet_api::block::{BlockNumber, BlockTimestamp};
 use katana_cairo::starknet_api::core::{
-    self, ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce,
+    self, ChainId, ClassHash, CompiledClassHash, ContractAddress, EntryPointSelector, Nonce,
 };
 use katana_cairo::starknet_api::data_availability::DataAvailabilityMode;
 use katana_cairo::starknet_api::deprecated_contract_class::EntryPointType;
@@ -184,6 +184,25 @@ pub fn to_executor_tx(tx: ExecutableTxWithHash) -> Transaction {
 
     match tx.transaction {
         ExecutableTx::Invoke(tx) => match tx {
+            InvokeTx::V0(tx) => {
+                let calldata = tx.calldata;
+                let signature = tx.signature;
+
+                Transaction::AccountTransaction(AccountTransaction::Invoke(InvokeTransaction {
+                    tx: ApiInvokeTransaction::V0(
+                        katana_cairo::starknet_api::transaction::InvokeTransactionV0 {
+                            entry_point_selector: EntryPointSelector(tx.entry_point_selector),
+                            contract_address: to_blk_address(tx.contract_address),
+                            signature: TransactionSignature(signature),
+                            calldata: Calldata(Arc::new(calldata)),
+                            max_fee: Fee(tx.max_fee),
+                        },
+                    ),
+                    tx_hash: TransactionHash(hash),
+                    only_query: false,
+                }))
+            }
+
             InvokeTx::V1(tx) => {
                 let calldata = tx.calldata;
                 let signature = tx.signature;

crates/katana/feeder-gateway/src/client.rs

@@ -57,7 +57,7 @@ impl SequencerGateway {
         block_id: BlockIdOrTag,
     ) -> Result<StateUpdateWithBlock, Error> {
         self.feeder_gateway("get_state_update")
-            .with_query_param("includeBlock", "true")
+            .add_query_param("includeBlock", "true")
             .with_block_id(block_id)
             .send()
             .await
@@ -69,7 +69,7 @@ impl SequencerGateway {
         block_id: BlockIdOrTag,
     ) -> Result<ContractClass, Error> {
         self.feeder_gateway("get_class_by_hash")
-            .with_query_param("classHash", &format!("{hash:#x}"))
+            .add_query_param("classHash", &format!("{hash:#x}"))
             .with_block_id(block_id)
             .send()
             .await
@@ -81,7 +81,7 @@ impl SequencerGateway {
         block_id: BlockIdOrTag,
     ) -> Result<CasmContractClass, Error> {
         self.feeder_gateway("get_compiled_class_by_class_hash")
-            .with_query_param("classHash", &format!("{hash:#x}"))
+            .add_query_param("classHash", &format!("{hash:#x}"))
             .with_block_id(block_id)
             .send()
             .await
@@ -112,13 +112,13 @@ impl<'a> RequestBuilder<'a> {
         match block_id {
             // latest block is implied, if no block id specified
             BlockIdOrTag::Tag(BlockTag::Latest) => self,
-            BlockIdOrTag::Tag(BlockTag::Pending) => self.with_query_param("blockNumber", "pending"),
-            BlockIdOrTag::Hash(hash) => self.with_query_param("blockHash", &format!("{hash:#x}")),
-            BlockIdOrTag::Number(num) => self.with_query_param("blockNumber", &num.to_string()),
+            BlockIdOrTag::Tag(BlockTag::Pending) => self.add_query_param("blockNumber", "pending"),
+            BlockIdOrTag::Hash(hash) => self.add_query_param("blockHash", &format!("{hash:#x}")),
+            BlockIdOrTag::Number(num) => self.add_query_param("blockNumber", &num.to_string()),
         }
     }
 
-    fn with_query_param(mut self, key: &str, value: &str) -> Self {
+    fn add_query_param(mut self, key: &str, value: &str) -> Self {
         self.url.query_pairs_mut().append_pair(key, value);
         self
     }
@@ -181,6 +181,7 @@ pub enum ErrorCode {
 
 #[cfg(test)]
 mod tests {
+
     use super::*;
 
     #[test]
@@ -214,9 +215,9 @@ mod tests {
         let req = RequestBuilder { client: &client, url: base_url };
 
         let url = req
-            .with_query_param("param1", "value1")
-            .with_query_param("param2", "value2")
-            .with_query_param("param3", "value3")
+            .add_query_param("param1", "value1")
+            .add_query_param("param2", "value2")
+            .add_query_param("param3", "value3")
             .url;
 
         let query = url.query().unwrap();

crates/katana/feeder-gateway/src/types.rs → crates/katana/feeder-gateway/src/types/mod.rs

@@ -1,15 +1,25 @@
 use std::collections::{BTreeMap, BTreeSet};
 
+use katana_primitives::block::{BlockHash, BlockNumber};
 pub use katana_primitives::class::CasmContractClass;
 use katana_primitives::class::{
     ClassHash, CompiledClassHash, LegacyContractClass, SierraContractClass,
 };
 use katana_primitives::contract::{Nonce, StorageKey, StorageValue};
+use katana_primitives::da::L1DataAvailabilityMode;
+use katana_primitives::version::ProtocolVersion;
 use katana_primitives::{ContractAddress, Felt};
 use katana_rpc_types::class::ConversionError;
 pub use katana_rpc_types::class::RpcSierraContractClass;
 use serde::Deserialize;
-use starknet::providers::sequencer::models::Block;
+use starknet::core::types::ResourcePrice;
+use starknet::providers::sequencer::models::BlockStatus;
+
+mod receipt;
+mod transaction;
+
+pub use receipt::*;
+pub use transaction::*;
 
 /// The contract class type returns by `/get_class_by_hash` endpoint.
 #[derive(Debug, Deserialize)]
@@ -63,6 +73,35 @@ pub struct StateUpdateWithBlock {
     pub block: Block,
 }
 
+// The reason why we're not using the GasPrices from the `katana_primitives` crate is because
+// the serde impl is different. So for now, lets just use starknet-rs types. The type isn't
+// that complex anyway so the conversion is simple. But if we can use the primitive types, we
+// should.
+#[derive(Debug, Deserialize)]
+pub struct Block {
+    #[serde(default)]
+    pub block_hash: Option<BlockHash>,
+    #[serde(default)]
+    pub block_number: Option<BlockNumber>,
+    pub parent_block_hash: BlockHash,
+    pub timestamp: u64,
+    pub sequencer_address: Option<ContractAddress>,
+    #[serde(default)]
+    pub state_root: Option<Felt>,
+    #[serde(default)]
+    pub transaction_commitment: Option<Felt>,
+    #[serde(default)]
+    pub event_commitment: Option<Felt>,
+    pub status: BlockStatus,
+    pub l1_da_mode: L1DataAvailabilityMode,
+    pub l1_gas_price: ResourcePrice,
+    pub l1_data_gas_price: ResourcePrice,
+    pub transactions: Vec<ConfirmedTransaction>,
+    pub transaction_receipts: Vec<ConfirmedReceipt>,
+    #[serde(default)]
+    pub starknet_version: Option<ProtocolVersion>,
+}
+
 // -- Conversion to Katana primitive types.
 
 impl TryFrom<ContractClass> for katana_primitives::class::ContractClass {

crates/katana/feeder-gateway/src/types/receipt.rs

@@ -0,0 +1,22 @@
+use katana_primitives::receipt::{Event, MessageToL1};
+use katana_primitives::Felt;
+use serde::Deserialize;
+use starknet::providers::sequencer::models::{
+    ExecutionResources, L1ToL2Message, TransactionExecutionStatus,
+};
+
+#[derive(Debug, Deserialize)]
+pub struct ConfirmedReceipt {
+    pub transaction_hash: Felt,
+    pub transaction_index: u64,
+    #[serde(default)]
+    pub execution_status: Option<TransactionExecutionStatus>,
+    #[serde(default)]
+    pub revert_error: Option<String>,
+    #[serde(default)]
+    pub execution_resources: Option<ExecutionResources>,
+    pub l1_to_l2_consumed_message: Option<L1ToL2Message>,
+    pub l2_to_l1_messages: Vec<MessageToL1>,
+    pub events: Vec<Event>,
+    pub actual_fee: Felt,
+}