feat: algokit_utils (Rust impl only)

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
 resolver = "2"
-members = [
+members = [ "crates/algod_api", "crates/algokit_http_client",
   "crates/algokit_transact",
-  "crates/algokit_transact_ffi",
+  "crates/algokit_transact_ffi", "crates/algokit_utils",
+  "crates/ffi_macros", "crates/ffi_mutex",
   "tools/build_pkgs",
-  "crates/ffi_macros",
   "crates/uniffi-bindgen",
   "docs",
   "tools/cargo-bin",

crates/algod_api/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "algod_api"
+version = "0.1.0"
+edition = "2024"
+
+[features]
+default = ["default_http_client"]
+default_http_client = ["algokit_http_client/default_client"]
+
+
+[dependencies]
+algokit_http_client = { version = "0.1.0", path = "../algokit_http_client" }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"

crates/algod_api/src/lib.rs

@@ -0,0 +1,47 @@
+use std::sync::Arc;
+
+use algokit_http_client::{HttpClient, HttpError};
+
+#[cfg(feature = "default_http_client")]
+use algokit_http_client::DefaultHttpClient;
+
+use serde::{Deserialize, Serialize};
+
+pub struct AlgodClient {
+    http_client: Arc<dyn HttpClient>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct TransactionParams {
+    pub consensus_version: String,
+    pub fee: u64,
+    pub last_round: u64,
+    pub genesis_id: String,
+    pub genesis_hash: String,
+    pub min_fee: u64,
+}
+
+/// A temporary AlgodClient until the proper client is generated.
+/// The exepectation is that this client will use a HttpClient to make requests to the Algorand API
+impl AlgodClient {
+    pub fn new(http_client: Arc<dyn HttpClient>) -> Self {
+        AlgodClient { http_client }
+    }
+
+    #[cfg(feature = "default_http_client")]
+    pub fn testnet() -> Self {
+        AlgodClient {
+            http_client: Arc::new(DefaultHttpClient::new(
+                "https://testnet-api.4160.nodely.dev",
+            )),
+        }
+    }
+
+    pub async fn transaction_params(&self) -> Result<TransactionParams, HttpError> {
+        let path = "/v2/transactions/params".to_string();
+        let response = self.http_client.get(path).await?;
+
+        serde_json::from_slice(&response).map_err(|e| HttpError::HttpError(e.to_string()))
+    }
+}

crates/algokit_http_client/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "algokit_http_client"
+version = "0.1.0"
+edition = "2024"
+
+[features]
+default = ["default_client"]
+ffi_uniffi = ["dep:uniffi"]
+ffi_wasm = ["dep:wasm-bindgen", "dep:js-sys"]
+default_client = ["dep:reqwest"]
+
+[dependencies]
+async-trait = "0.1.88"
+js-sys = { workspace = true, optional = true }
+reqwest = { version = "0.12.19", optional = true }
+thiserror.workspace = true
+uniffi = { workspace = true, optional = true }
+wasm-bindgen = { workspace = true, optional = true }
+wasm-bindgen-futures = "0.4.50"

crates/algokit_http_client/src/lib.rs

@@ -0,0 +1,98 @@
+use async_trait::async_trait;
+
+#[cfg(feature = "ffi_uniffi")]
+uniffi::setup_scaffolding!();
+
+#[derive(Debug, thiserror::Error)]
+#[cfg_attr(feature = "ffi_uniffi", derive(uniffi::Error))]
+pub enum HttpError {
+    #[error("HttpError: {0}")]
+    HttpError(String),
+}
+
+#[cfg(not(feature = "ffi_wasm"))]
+#[cfg_attr(feature = "ffi_uniffi", uniffi::export(with_foreign))]
+#[async_trait]
+/// This trait must be implemented by any HTTP client that is used by our Rust crates.
+/// It is assumed the implementing type will provide the hostname, port, headers, etc. as needed for each request.
+///
+/// By default, this trait requires the implementing type to be `Send + Sync`.
+/// For WASM targets, enable the `ffi_wasm` feature to use a different implementation that is compatible with WASM.
+///
+/// With the `ffi_uniffi` feature enabled, this is exported as a foreign trait, meaning it is implemented natively in the foreign language.
+///
+pub trait HttpClient: Send + Sync {
+    async fn get(&self, path: String) -> Result<Vec<u8>, HttpError>;
+}
+
+#[cfg(feature = "default_client")]
+pub struct DefaultHttpClient {
+    host: String,
+}
+
+#[cfg(feature = "default_client")]
+impl DefaultHttpClient {
+    pub fn new(host: &str) -> Self {
+        DefaultHttpClient {
+            host: host.to_string(),
+        }
+    }
+}
+
+#[cfg(feature = "default_client")]
+#[cfg_attr(feature = "ffi_wasm", async_trait(?Send))]
+#[cfg_attr(not(feature = "ffi_wasm"), async_trait)]
+impl HttpClient for DefaultHttpClient {
+    async fn get(&self, path: String) -> Result<Vec<u8>, HttpError> {
+        let response = reqwest::get(self.host.clone() + &path)
+            .await
+            .map_err(|e| HttpError::HttpError(e.to_string()))?
+            .bytes()
+            .await
+            .map_err(|e| HttpError::HttpError(e.to_string()))?
+            .to_vec();
+
+        Ok(response)
+    }
+}
+
+#[cfg(feature = "ffi_wasm")]
+use wasm_bindgen::prelude::*;
+
+#[cfg(feature = "ffi_wasm")]
+use js_sys::Uint8Array;
+
+#[cfg(feature = "ffi_wasm")]
+#[async_trait(?Send)]
+pub trait HttpClient {
+    async fn get(&self, path: String) -> Result<Vec<u8>, HttpError>;
+}
+
+#[wasm_bindgen]
+#[cfg(feature = "ffi_wasm")]
+extern "C" {
+    /// The interface for the JavaScript-based HTTP client that will be used in WASM environments.
+    ///
+    /// This mirrors the `HttpClient` trait, but wasm-bindgen doesn't support foreign traits so we define it separately.
+    pub type WasmHttpClient;
+
+    #[wasm_bindgen(method, catch)]
+    async fn get(this: &WasmHttpClient, path: &str) -> Result<Uint8Array, JsValue>;
+}
+
+#[cfg(feature = "ffi_wasm")]
+#[async_trait(?Send)]
+impl HttpClient for WasmHttpClient {
+    async fn get(&self, path: String) -> Result<Vec<u8>, HttpError> {
+        let result = self.get(&path).await.map_err(|e| {
+            HttpError::HttpError(
+                e.as_string().unwrap_or(
+                    "A HTTP error ocurred in JavaScript, but it cannot be converted to a string"
+                        .to_string(),
+                ),
+            )
+        })?;
+
+        Ok(result.to_vec())
+    }
+}

crates/algokit_transact_ffi/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib", "staticlib"]
+crate-type = ["lib", "cdylib", "staticlib"]
 
 [features]
 default = ["ffi_uniffi"]

crates/algokit_utils/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "algokit_utils"
+version = "0.1.0"
+edition = "2024"
+
+[features]
+default = ["default_http_client"]
+default_http_client = ["dep:reqwest", "algokit_http_client/default_client"]
+
+[dependencies]
+algod_api = { version = "0.1.0", path = "../algod_api" }
+algokit_http_client = { version = "0.1.0", path = "../algokit_http_client", default-features = false }
+algokit_transact = { version = "0.1.0", path = "../algokit_transact", features = ["test_utils"] }
+async-trait = { version = "0.1.88" }
+base64 = "0.22.1"
+derive_more = { version = "2.0.1", features = ["full"] }
+reqwest = { version = "0.12.19", features = ["blocking"], optional = true }
+thiserror.workspace = true
+
+[dev-dependencies]
+tokio = { version = "1.45.1", features = ["full", "test-util"] }