feat: gateway send requests

Author: MarcosNicolau

crates/sdk/src/aggregation_layer/gateway.rs

@@ -0,0 +1,2 @@
+pub mod provider;
+pub mod types;

crates/sdk/src/aggregation_layer/gateway/mod.rs

@@ -0,0 +1,101 @@
+use reqwest::Client;
+use serde::de::DeserializeOwned;
+
+use crate::{
+    aggregation_layer::gateway::types::{
+        GatewayResponse, NonceResponse, Receipt, ReceiptsQuery, ReceiptsResponse,
+    },
+    common::types::Network,
+};
+
+pub struct AggregationModeGatewayProvider {
+    gateway_url: String,
+    http_client: Client,
+}
+
+#[derive(Debug)]
+pub enum AggregationModeError {
+    UnsupportedNetwork,
+    Request(String),
+    Api { status: u16, message: String },
+}
+
+impl AggregationModeGatewayProvider {
+    pub fn new(network: Network) -> Result<Self, AggregationModeError> {
+        let gateway_url = match network {
+            Network::Devnet => "http://127.0.0.1:8089".into(),
+
+            _ => return Err(AggregationModeError::UnsupportedNetwork),
+        };
+
+        Ok(Self {
+            gateway_url,
+            http_client: Client::new(),
+        })
+    }
+
+    pub fn new_with_signer() {}
+
+    pub fn signer() {}
+}
+
+impl AggregationModeGatewayProvider {
+    pub async fn gateway_url(&self) -> &str {
+        &self.gateway_url
+    }
+
+    pub async fn get_nonce_for(&self, address: String) -> Result<u64, AggregationModeError> {
+        let url = format!("{}/nonce/{}", self.gateway_url, address);
+        let response: NonceResponse = self.send_request(self.http_client.get(url)).await?;
+
+        Ok(response.nonce)
+    }
+
+    pub async fn get_receipts_for(
+        &self,
+        address: String,
+        nonce: Option<u64>,
+    ) -> Result<Vec<Receipt>, AggregationModeError> {
+        let query = ReceiptsQuery {
+            address: address,
+            nonce,
+        };
+
+        let request = self
+            .http_client
+            .get(format!("{}/receipts", self.gateway_url))
+            .query(&query);
+
+        let response: ReceiptsResponse = self.send_request(request).await?;
+
+        Ok(response.receipts)
+    }
+
+    pub async fn submit_sp1_proof(&self, serialized_proof: Vec<u8>, serialized_vk: Vec<u8>) {}
+
+    // TODO: verify proof from receipt merkle path
+
+    async fn send_request<T: DeserializeOwned>(
+        &self,
+        request: reqwest::RequestBuilder,
+    ) -> Result<T, AggregationModeError> {
+        let response = request
+            .send()
+            .await
+            .map_err(|e| AggregationModeError::Request(e.to_string()))?;
+
+        let payload: GatewayResponse<T> = response
+            .json()
+            .await
+            .map_err(|e| AggregationModeError::Request(e.to_string()))?;
+
+        if payload.status != 200 {
+            return Err(AggregationModeError::Api {
+                status: payload.status,
+                message: payload.message,
+            });
+        }
+
+        Ok(payload.data)
+    }
+}

crates/sdk/src/aggregation_layer/gateway/provider.rs

@@ -0,0 +1,61 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize)]
+pub(super) struct GatewayResponse<T> {
+    pub status: u16,
+    pub message: String,
+    pub data: T,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct NonceResponse {
+    pub nonce: u64,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ReceiptsQuery {
+    pub address: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<u64>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Receipt {
+    pub status: String,
+    pub merkle_path: Vec<String>,
+    pub nonce: i64,
+    pub address: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct ReceiptsResponse {
+    pub receipts: Vec<Receipt>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SubmitSP1ProofMessage {
+    nonce: u64,
+    proof: Vec<u8>,
+    program_vk: Vec<u8>,
+    signature: Vec<u8>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SubmitProofResponse {
+    pub task_id: String,
+}
+
+impl SubmitSP1ProofMessage {
+    pub fn new(nonce: u64, serialized_proof: Vec<u8>, serialized_vk: Vec<u8>) -> Self {
+        Self {
+            nonce,
+            proof: serialized_proof,
+            program_vk: serialized_vk,
+            signature: vec![],
+        }
+    }
+
+    pub fn sign(mut self) -> Self {
+        self
+    }
+}