feat(katana): modify DevApi trait with new endpoints

crates/katana/primitives/src/fee.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -29,6 +31,17 @@
     Fri,
 }
 
+impl FromStr for PriceUnit {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "WEI" => Ok(PriceUnit::Wei),
+            "FRI" => Ok(PriceUnit::Fri),
+            _ => Err(()), // Return an error for unknown units
+        }
+    }
+}
+
 /// Information regarding the fee and gas usages of a transaction.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]

crates/katana/primitives/src/genesis/constant.rs

@@ -1,9 +1,11 @@
+use anyhow::Error;
 use lazy_static::lazy_static;
 use starknet::core::utils::get_storage_var_address;
 use starknet::macros::felt;
 
 use crate::class::{ClassHash, CompiledClass, CompiledClassHash, ContractClass};
 use crate::contract::{ContractAddress, StorageKey};
+use crate::fee::PriceUnit;
 use crate::utils::class::{
     parse_compiled_class, parse_deprecated_compiled_class, parse_sierra_class,
 };
@@ -117,6 +119,15 @@
     ContractClass::Legacy(class)
 }
 
+pub fn get_erc20_address(unit: &PriceUnit) -> Result<ContractAddress, Error> {
+    let erc20_contract_address = match unit {
+        PriceUnit::Wei => DEFAULT_ETH_FEE_TOKEN_ADDRESS,
+        PriceUnit::Fri => DEFAULT_STRK_FEE_TOKEN_ADDRESS,
+    };
+
+    Ok(ContractAddress::new(erc20_contract_address.into()))
+}
+
 #[cfg(test)]
 mod tests {
 

crates/katana/rpc/rpc-api/src/dev.rs

@@ -24,4 +24,10 @@ pub trait DevApi {
 
     #[method(name = "predeployedAccounts")]
     async fn predeployed_accounts(&self) -> RpcResult<Vec<Account>>;
+
+    #[method(name = "accountBalance")]
+    async fn account_balance(&self, address: String, unit: String) -> RpcResult<u128>;
+
+    #[method(name = "mint")]
+    async fn mint(&self) -> RpcResult<()>;
 }

crates/katana/rpc/rpc/Cargo.toml

@@ -7,6 +7,9 @@ repository.workspace = true
 version.workspace = true
 
 [dependencies]
+jsonrpsee-core = { version = "0.16.3", features = [ "server", "soketto", "http-helpers" ] }
+jsonrpsee-types = { version = "0.16.3"}
+hyper.workspace = true
 katana-core.workspace = true
 katana-executor.workspace = true
 katana-pool.workspace = true
@@ -31,6 +34,16 @@ tower.workspace = true
 tower-http.workspace = true
 tracing.workspace = true
 url.workspace = true
+serde.workspace = true
+soketto = { version = "0.7.1", features = ["http"] }
+futures-channel = { version = "0.3.14"}
+futures-util = { version = "0.3.14",  features = [
+    "io",
+    "async-await-macro",
+]}
+tokio-stream = { version = "0.1.7" }
+tokio-util = { version = "0.7", features = ["compat"]}
+starknet-crypto.workspace = true
 
 [dev-dependencies]
 katana-cairo.workspace = true

crates/katana/rpc/rpc/src/dev.rs

@@ -1,13 +1,22 @@
+use std::str::FromStr;
 use std::sync::Arc;
 
 use jsonrpsee::core::{async_trait, Error};
 use katana_core::backend::Backend;
 use katana_core::service::block_producer::{BlockProducer, BlockProducerMode, PendingExecutor};
 use katana_executor::ExecutorFactory;
-use katana_primitives::Felt;
+use katana_primitives::fee::PriceUnit;
+use katana_primitives::genesis::constant::{
+    get_erc20_address, get_fee_token_balance_base_storage_address,
+};
+use katana_primitives::ContractAddress;
+use katana_provider::traits::state::StateFactoryProvider;
 use katana_rpc_api::dev::DevApiServer;
 use katana_rpc_types::account::Account;
 use katana_rpc_types::error::dev::DevApiError;
+use starknet_crypto::Felt;
+
+use crate::transport::http;
 
 #[allow(missing_debug_implementations)]
 pub struct DevApi<EF: ExecutorFactory> {
@@ -54,7 +63,6 @@
 
         let mut block_context_generator = self.backend.block_context_generator.write();
         block_context_generator.block_timestamp_offset += offset as i64;
-
         Ok(())
     }
 }
@@ -92,6 +100,25 @@
         Ok(())
     }
 
+    async fn account_balance(&self, address: String, unit: String) -> Result<u128, Error> {
+        let account_address: ContractAddress = Felt::from_str(address.as_str()).unwrap().into();
+        let unit = PriceUnit::from_str(unit.to_uppercase().as_str()).unwrap_or(PriceUnit::Wei);
+
+        let erc20_address =
+            get_erc20_address(&unit).map_err(|_| http::response::internal_error()).unwrap();
+
+        let provider = self.backend.blockchain.provider();
+        let state = provider.latest().unwrap();
+        let storage_slot = get_fee_token_balance_base_storage_address(account_address);
+        let balance_felt = state.storage(erc20_address, storage_slot).unwrap().unwrap();
+        let balance: u128 = balance_felt.to_string().parse().unwrap();
+        Ok(balance)
+    }
+
+    async fn mint(&self) -> Result<(), Error> {
+        Ok(())
+    }
+
     async fn predeployed_accounts(&self) -> Result<Vec<Account>, Error> {
         Ok(self.backend.chain_spec.genesis.accounts().map(|e| Account::new(*e.0, e.1)).collect())
     }

crates/katana/rpc/rpc/src/lib.rs

@@ -1,23 +1,22 @@
-//! RPC implementations.
-
-#![allow(clippy::blocks_in_conditions)]
-#![cfg_attr(not(test), warn(unused_crate_dependencies))]
-
 use std::net::SocketAddr;
 use std::time::Duration;
 
 use jsonrpsee::server::{AllowHosts, ServerBuilder, ServerHandle};
 use jsonrpsee::RpcModule;
+use proxy_get_request::DevnetProxyLayer;
 use tower::ServiceBuilder;
 use tracing::info;
 
 pub mod cors;
 pub mod dev;
 pub mod health;
 pub mod metrics;
+pub mod proxy_get_request;
 pub mod saya;
 pub mod starknet;
 pub mod torii;
+
+mod transport;
 mod utils;
 
 use cors::Cors;
@@ -116,6 +115,7 @@ impl RpcServer {
         let middleware = ServiceBuilder::new()
             .option_layer(self.cors.clone())
             .option_layer(health_check_proxy)
+            .layer(DevnetProxyLayer::new()?)
             .timeout(Duration::from_secs(20));
 
         let builder = ServerBuilder::new()

crates/katana/rpc/rpc/src/proxy_get_request.rs

@@ -0,0 +1,162 @@
+//! Middleware that proxies requests at a specified URI to internal
+//! RPC method calls.
+use std::collections::HashMap;
+use std::error::Error;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use hyper::header::{ACCEPT, CONTENT_TYPE};
+use hyper::http::HeaderValue;
+use hyper::{Body, Method, Request, Response, Uri};
+use jsonrpsee_core::error::Error as RpcError;
+use jsonrpsee_core::JsonRawValue;
+use jsonrpsee_types::{Id, RequestSer};
+use tower::{Layer, Service};
+use url::form_urlencoded;
+
+use crate::transport::http;
+
+/// Layer that applies [`DevnetProxy`] which proxies the `GET /path` requests to
+/// specific RPC method calls and that strips the response.
+///
+/// See [`DevnetProxy`] for more details.
+#[derive(Debug, Clone)]
+pub struct DevnetProxyLayer {}
+
+impl DevnetProxyLayer {
+    /// Creates a new [`DevnetProxyLayer`].
+    ///
+    /// See [`DevnetProxy`] for more details.
+    pub fn new() -> Result<Self, RpcError> {
+        Ok(Self {})
+    }
+}
+impl<S> Layer<S> for DevnetProxyLayer {
+    type Service = DevnetProxy<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        DevnetProxy::new(inner).expect("Path already validated in DevnetProxyLayer; qed")
+    }
+}
+
+/// Proxy `GET /path` requests to the specified RPC method calls.
+///
+/// # Request
+///
+/// The `GET /path` requests are modified into valid `POST` requests for
+/// calling the RPC method. This middleware adds appropriate headers to the
+/// request, and completely modifies the request `BODY`.
+///
+/// # Response
+///
+/// The response of the RPC method is stripped down to contain only the method's
+/// response, removing any RPC 2.0 spec logic regarding the response' body.
+#[derive(Debug, Clone)]
+pub struct DevnetProxy<S> {
+    inner: S,
+}
+
+impl<S> DevnetProxy<S> {
+    /// Creates a new [`DevnetProxy`].
+    ///
+    /// The request `GET /path` is redirected to the provided method.
+    /// Fails if the path does not start with `/`.
+    pub fn new(inner: S) -> Result<Self, RpcError> {
+        Ok(Self { inner })
+    }
+}
+
+impl<S> Service<Request<Body>> for DevnetProxy<S>
+where
+    S: Service<Request<Body>, Response = Response<Body>>,
+    S::Response: 'static,
+    S::Error: Into<Box<dyn Error + Send + Sync>> + 'static,
+    S::Future: Send + 'static,
+{
+    type Response = S::Response;
+    type Error = Box<dyn Error + Send + Sync + 'static>;
+    type Future =
+        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx).map_err(Into::into)
+    }
+
+    fn call(&mut self, mut req: Request<Body>) -> Self::Future {
+        let query = req.uri().query();
+        let path = req.uri().path();
+
+        let (params, method) = match path {
+            "/account_balance" => get_account_balance(query),
+            _ => (JsonRawValue::from_string("{}".to_string()).unwrap(), "".to_string()),
+        };
+
+        if !method.is_empty() {
+            // RPC methods are accessed with `POST`.
+            *req.method_mut() = Method::POST;
+            // Precautionary remove the URI.
+            *req.uri_mut() = Uri::from_static("/");
+
+            // Requests must have the following headers:
+            req.headers_mut().insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+            req.headers_mut().insert(ACCEPT, HeaderValue::from_static("application/json"));
+
+            // Adjust the body to reflect the method call.
+            let body = Body::from(
+                serde_json::to_string(&RequestSer::borrowed(
+                    &Id::Number(0),
+                    &method,
+                    Some(&params),
+                ))
+                .expect("Valid request; qed"),
+            );
+            req = req.map(|_| body);
+        }
+
+        // Call the inner service and get a future that resolves to the response.
+        let fut = self.inner.call(req);
+
+        // Adjust the response if needed.
+        let res_fut = async move {
+            let res = fut.await.map_err(|err| err.into())?;
+
+            if method.is_empty() {
+                return Ok(res);
+            }
+
+            let body = res.into_body();
+            let bytes = hyper::body::to_bytes(body).await?;
+
+            #[derive(serde::Deserialize, Debug)]
+            struct RpcPayload<'a> {
+                #[serde(borrow)]
+                result: &'a serde_json::value::RawValue,
+            }
+
+            let response = if let Ok(payload) = serde_json::from_slice::<RpcPayload<'_>>(&bytes) {
+                http::response::ok_response(payload.result.to_string())
+            } else {
+                http::response::internal_error()
+            };
+
+            Ok(response)
+        };
+
+        Box::pin(res_fut)
+    }
+}
+
+fn get_account_balance(query: Option<&str>) -> (Box<JsonRawValue>, std::string::String) {
+    let default = String::new();
+
+    let query = query.unwrap_or(&default);
+    let params: HashMap<_, _> = form_urlencoded::parse(query.as_bytes()).into_owned().collect();
+
+    let address = params.get("contract_address").unwrap_or(&default);
+    let unit = params.get("unit").unwrap_or(&default);
+
+    let json_string = format!(r#"{{"address":"{}", "unit":"{}"}}"#, address, unit);
+    (JsonRawValue::from_string(json_string).unwrap(), "dev_accountBalance".to_string())
+}