wip

Author: kariy

Cargo.lock

@@ -4,7 +4,8 @@ use std::task::{Context, Poll};
 
 use block_producer::BlockProductionError;
 use futures::stream::StreamExt;
-use katana_pool::{PendingTransactions, PoolOrd, TransactionPool, TxPool};
+use katana_pool::api::{PendingTransactions, PoolOrd, TransactionPool};
+use katana_pool::TxPool;
 use katana_primitives::transaction::ExecutableTxWithHash;
 use katana_provider::{ProviderFactory, ProviderRO, ProviderRW};
 use tracing::{error, info};

crates/core/src/service/mod.rs

@@ -5,7 +5,8 @@ use std::time::Duration;
 
 use futures::{Future, FutureExt, Stream};
 use katana_chain_spec::ChainSpec;
-use katana_pool::{TransactionPool, TxPool};
+use katana_pool::api::TransactionPool;
+use katana_pool::TxPool;
 use katana_primitives::chain::ChainId;
 use katana_primitives::transaction::{ExecutableTxWithHash, L1HandlerTx, TxHash};
 use tokio::time::{interval_at, Instant, Interval};

crates/messaging/src/service.rs

@@ -4,7 +4,6 @@ pub mod ordering;
 pub mod pool;
 pub mod validation;
 
-pub use katana_pool_api::{PendingTransactions, PoolOrd, PoolTransaction, TransactionPool};
 use katana_primitives::transaction::ExecutableTxWithHash;
 use ordering::FiFo;
 use pool::Pool;
@@ -13,6 +12,10 @@ use validation::stateful::TxValidator;
 /// Katana default transacstion pool type.
 pub type TxPool = Pool<ExecutableTxWithHash, TxValidator, FiFo<ExecutableTxWithHash>>;
 
+pub mod api {
+    pub use katana_pool_api::*;
+}
+
 #[cfg(test)]
 mod tests {
 

crates/pool/pool/src/lib.rs

@@ -14,6 +14,7 @@ katana-explorer = { workspace = true, features = [ "jsonrpsee" ], optional = tru
 katana-metrics.workspace = true
 katana-pool.workspace = true
 katana-primitives.workspace = true
+katana-paymaster.workspace = true
 katana-genesis = { workspace = true, optional = true }
 katana-provider = { workspace = true, features = [ "test-utils" ] }
 katana-rpc-api = { workspace = true, features = [ "client" ] }
@@ -36,6 +37,7 @@ tokio.workspace = true
 tower.workspace = true
 tower-http = { workspace = true, features = [ "cors", "trace" ] }
 tracing.workspace = true
+serde.workspace = true
 
 cainome = { workspace = true, optional = true }
 cartridge = { workspace = true, optional = true }
@@ -71,7 +73,6 @@ jsonrpsee = { workspace = true, features = [ "client" ] }
 num-traits.workspace = true
 rand.workspace = true
 rstest.workspace = true
-serde.workspace = true
 serde_json.workspace = true
 similar-asserts.workspace = true
 starknet.workspace = true

crates/rpc/rpc-server/Cargo.toml

@@ -32,14 +32,14 @@ use std::sync::Arc;
 
 use anyhow::anyhow;
 use cainome::cairo_serde::CairoSerde;
-use cartridge::vrf::SignedOutsideExecution;
 use http::{HeaderMap, HeaderName, HeaderValue};
 use jsonrpsee::core::{async_trait, RpcResult};
 use jsonrpsee::http_client::{HttpClient, HttpClientBuilder};
 use katana_core::backend::Backend;
 use katana_core::service::block_producer::{BlockProducer, BlockProducerMode};
 use katana_genesis::constant::{DEFAULT_STRK_FEE_TOKEN_ADDRESS, DEFAULT_UDC_ADDRESS};
-use katana_pool::{TransactionPool, TxPool};
+use katana_pool::api::TransactionPool;
+use katana_pool::TxPool;
 use katana_primitives::chain::ChainId;
 use katana_primitives::contract::Nonce;
 use katana_primitives::execution::Call;
@@ -53,9 +53,7 @@ use katana_rpc_api::error::cartridge::CartridgeApiError;
 use katana_rpc_api::paymaster::PaymasterApiClient;
 use katana_rpc_types::broadcasted::AddInvokeTransactionResponse;
 use katana_rpc_types::cartridge::FeeSource;
-use katana_rpc_types::outside_execution::{
-    OutsideExecution, OutsideExecutionV2, OutsideExecutionV3,
-};
+use katana_rpc_types::outside_execution::OutsideExecution;
 use katana_rpc_types::FunctionCall;
 use katana_tasks::{Result as TaskResult, TaskSpawner};
 use paymaster_rpc::{
@@ -218,7 +216,7 @@ where
             let mut calldata = outside_execution.as_felts();
             calldata.extend(signature);
 
-            let mut call = Call { contract_address, entry_point_selector, calldata };
+            let mut call: Call = Call { contract_address, entry_point_selector, calldata };
             let mut user_address: Felt = contract_address.into();
 
             #[cfg(feature = "vrf")]
@@ -231,7 +229,7 @@ where
                         return Err(CartridgeApiError::VrfMissingFollowUpCall);
                     }
 
-                    if request_random_call.to != vrf_service.account_address() {
+                    if request_random_call.contract_address != vrf_service.account_address() {
                         return Err(CartridgeApiError::VrfInvalidTarget);
                     }
 
@@ -247,7 +245,7 @@ where
                         .await?;
 
                     user_address = result.address.into();
-                    call = build_execute_from_outside_call_from_vrf_result(&result);
+                    call = result.into();
                 }
             }
 
@@ -353,13 +351,8 @@ where
 pub fn encode_calls(calls: Vec<FunctionCall>) -> Vec<Felt> {
     let mut execute_calldata: Vec<Felt> = vec![calls.len().into()];
     for call in calls {
-        execute_calldata.push(call.contract_address.into());
-        execute_calldata.push(call.entry_point_selector);
-
-        execute_calldata.push(call.calldata.len().into());
-        execute_calldata.extend_from_slice(&call.calldata);
+        execute_calldata.extend(Call::cairo_serialize(&call));
     }
-
     execute_calldata
 }
 
@@ -462,20 +455,3 @@ pub async fn craft_deploy_cartridge_controller_tx(
         Ok(None)
     }
 }
-
-pub fn build_execute_from_outside_call_from_vrf_result(result: &SignedOutsideExecution) -> Call {
-    let (selector, calldata) = match &result.outside_execution {
-        cartridge::vrf::VrfOutsideExecution::V2(v2) => {
-            let mut calldata = OutsideExecutionV2::cairo_serialize(v2);
-            calldata.extend(Vec::<Felt>::cairo_serialize(&result.signature));
-            (selector!("execute_from_outside_v2"), calldata)
-        }
-        cartridge::vrf::VrfOutsideExecution::V3(v3) => {
-            let mut calldata = OutsideExecutionV3::cairo_serialize(v3);
-            calldata.extend(Vec::<Felt>::cairo_serialize(&result.signature));
-            (selector!("execute_from_outside_v3"), calldata)
-        }
-    };
-
-    PaymasterCall { to: result.address, selector, calldata }
-}

crates/rpc/rpc-server/src/cartridge/mod.rs

@@ -1,9 +1,8 @@
 //! VRF (Verifiable Random Function) service for Cartridge.
 
-use cartridge::vrf::client::SignedOutsideExecution;
-use cartridge::vrf::{RequestContext, SignedOutsideExecution, VrfOutsideExecution};
-use cartridge::VrfClient;
+use cartridge::vrf::{RequestContext, SignedOutsideExecution, VrfClient, VrfOutsideExecution};
 use katana_primitives::chain::ChainId;
+use katana_primitives::execution::Call;
 use katana_primitives::{ContractAddress, Felt};
 use katana_rpc_api::error::cartridge::CartridgeApiError;
 use katana_rpc_types::outside_execution::OutsideExecution;
@@ -17,7 +16,7 @@ pub struct VrfServiceConfig {
     pub vrf_contract: ContractAddress,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct VrfService {
     client: VrfClient,
     account_address: ContractAddress,
@@ -72,11 +71,11 @@ impl VrfService {
 
 pub(super) fn get_request_random_call(
     outside_execution: &OutsideExecution,
-) -> Option<(katana_rpc_types::outside_execution::Call, usize)> {
-    outside_execution
-        .calls()
+) -> Option<(Call, usize)> {
+    let calls = outside_execution.calls();
+    calls
         .iter()
-        .position(|call| call.selector == selector!("request_random"))
+        .position(|call| call.entry_point_selector == selector!("request_random"))
         .map(|position| (calls[position].clone(), position))
 }
 

crates/rpc/rpc-server/src/cartridge/vrf.rs

@@ -32,11 +32,11 @@ pub mod permit;
 pub mod starknet;
 
 mod utils;
-use cors::Cors;
 use health::HealthCheck;
 pub use jsonrpsee::core::middleware::RpcServiceBuilder;
 pub use jsonrpsee::http_client::HttpClient;
 pub use katana_rpc_api as api;
+use middleware::cors::Cors;
 
 /// The default maximum number of concurrent RPC connections.
 pub const DEFAULT_RPC_MAX_CONNECTIONS: u32 = 100;