Initial API defs

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "hs-builder-api"
+name = "hotshot-events-service"
 version = "0.1.1"
 edition = "2021"
 
@@ -10,7 +10,7 @@ async-trait = "0.1"
 clap = { version = "4.4", features = ["derive", "env"] }
 derive_more = "0.99"
 futures = "0.3"
-hotshot-types = { git = "https://github.com/EspressoSystems/HotShot.git", tag = "0.5.21" }
+hotshot-types = { git = "https://github.com/EspressoSystems/hotshot-types.git", tag = "v0.1.0" }
 serde = { version = "1.0", features = ["derive"] }
 snafu = { version = "0.7", features = ["backtraces"] }
 tagged-base64 = { git = "https://github.com/EspressoSystems/tagged-base64", tag = "0.3.4" }

README.md

@@ -1,5 +1,5 @@
 # hotshot-events-service
 
-Minimal dependencies shared API definitions for Internal HotShot Events
+Minimal dependencies shared API definitions to serve Internal HotShot Events
 
 # HotShot Consensus Module

src/events.rs

@@ -0,0 +1,123 @@
+use std::{fmt::Display, path::PathBuf};
+
+use clap::Args;
+use derive_more::From;
+use futures::FutureExt;
+use hotshot_types::{
+    traits::{node_implementation::NodeType, signature_key::SignatureKey},
+    utils::BuilderCommitment,
+};
+use serde::{Deserialize, Serialize};
+use snafu::{ResultExt, Snafu};
+use tagged_base64::TaggedBase64;
+use tide_disco::{
+    api::ApiError,
+    method::{ReadState, WriteState},
+    Api, RequestError, StatusCode,
+};
+
+use crate::{
+    api::load_api,
+    events_source::{EventsSource},
+};
+
+#[derive(Args, Default)]
+pub struct Options {
+    #[arg(long = "hotshot-events-service-api-path", env = "HOTSHOT_EVENTS_SERVICE_API_PATH")]
+    pub api_path: Option<PathBuf>,
+
+    /// Additional API specification files to merge with `hotshot-events-service-api-path`.
+    ///
+    /// These optional files may contain route definitions for application-specific routes that have
+    /// been added as extensions to the basic hotshot-events-service API.
+    #[arg(
+        long = "hotshot-events-extension",
+        env = "HOTSHOT_EVENTS_SERVICE_EXTENSIONS",
+        value_delimiter = ','
+    )]
+    pub extensions: Vec<toml::Value>,
+}
+
+#[derive(Clone, Debug, Snafu, Deserialize, Serialize)]
+#[snafu(visibility(pub))]
+pub enum EventError {
+    /// The requested resource does not exist or is not known to this hotshot node.
+    NotFound,
+    /// The requested resource exists but is not currently available.
+    Missing,
+    /// There was an error while trying to fetch the requested resource.
+    #[snafu(display("Failed to fetch requested resource: {message}"))]
+    Error { message: String },
+}
+
+
+#[derive(Clone, Debug, From, Snafu, Deserialize, Serialize)]
+#[snafu(visibility(pub))]
+pub enum Error {
+    Request {
+        source: RequestError,
+    },
+    #[snafu(display("error receiving events {resource}: {source}"))]
+    #[from(ignore)]
+    EventAvailable {
+        source: EventError,
+        resource: String,
+    },
+    Custom {
+        message: String,
+        status: StatusCode,
+    },
+}
+
+impl tide_disco::error::Error for Error {
+    fn catch_all(status: StatusCode, msg: String) -> Self {
+        Error::Custom {
+            message: msg,
+            status,
+        }
+    }
+
+    fn status(&self) -> StatusCode {
+        match self {
+            Error::Request { .. } => StatusCode::BadRequest,
+            Error::EventAvailable { source, .. } => match source
+            {
+                EventError::NotFound => StatusCode::NotFound,
+                EventError::Missing => StatusCode::NotFound,
+                EventError::Error { .. } => StatusCode::InternalServerError,
+            },
+        }
+    }
+}
+
+pub fn define_api<State, Types: NodeType>(options: &Options) -> Result<Api<State, Error>, ApiError>
+where
+    State: 'static + Send + Sync + ReadState,
+    <State as ReadState>::State: Send + Sync + EventsSource<Types>,
+    Types: NodeType,
+    <<Types as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType:
+        for<'a> TryFrom<&'a TaggedBase64> + Into<TaggedBase64> + Display,
+    for<'a> <<<Types as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType as TryFrom<
+        &'a TaggedBase64,
+    >>::Error: Display,
+{
+    let mut api = load_api::<State, Error>(
+        options.api_path.as_ref(),
+        include_str!("../api/hotshot_events.toml"),
+        options.extensions.clone(),
+    )?;
+    api.with_version("0.0.1".parse().unwrap())
+        .get("available_hotshot_events", |req, state| {
+            async move {
+                let view_number= req.blob_param("view_number")?;
+                state
+                    .get_available_hotshot_events(view_number)
+                    .await
+                    .context(EventAvailableSnafu {
+                        resource: view_number.to_string(),
+                    })
+            }
+            .boxed()
+        })?;
+    Ok(api)
+}

src/events_info.rs

@@ -0,0 +1,16 @@
+use hotshot_types::event::Event;
+use hotshot_types::{
+    traits::{node_implementation::NodeType, signature_key::SignatureKey},
+    utils::BuilderCommitment,
+    vid::VidCommitment,
+};
+use serde::{Deserialize, Serialize};
+use snafu::{ResultExt, Snafu};
+use std::{hash::Hash, marker::PhantomData};
+#[derive(Clone, Debug)]
+pub struct EventInfo<I: NodeType> {
+    pub event: Event<I>,
+    pub signature: <<I as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType,
+    pub sender: <I as NodeType>::SignatureKey,
+    pub _phantom: PhantomData<I>,
+}

src/events_source.rs

@@ -0,0 +1,25 @@
+use async_trait::async_trait;
+use std::{hash::Hash, marker::PhantomData};
+use hotshot_types::event::Event;
+use serde::{Deserialize, Serialize};
+use hotshot_types::{
+    traits::{node_implementation::NodeType, signature_key::SignatureKey},
+    utils::BuilderCommitment,
+    vid::VidCommitment,
+    data::ViewNumber
+};
+use tagged_base64::TaggedBase64;
+use crate::{events_info::{EventInfo}, events::EventError};
+
+#[async_trait]
+pub trait EventsSource<I>
+where
+    I: NodeType,
+    <<I as NodeType>::SignatureKey as SignatureKey>::PureAssembledSignatureType:
+        for<'a> TryFrom<&'a TaggedBase64> + Into<TaggedBase64>,
+{
+    async fn get_available_hotshot_events(
+        &self,
+        view_number: ViewNumber,
+    ) -> Result<Vec<EventInfo<I>>, EventError>;
+}

src/lib.rs

@@ -1 +1,4 @@
 mod api;
+pub mod events;
+pub mod events_info;
+pub mod events_source;