feat: Hermes events implementation

hermes/bin/src/event_queue/event.rs

@@ -3,7 +3,7 @@
 use crate::wasm::module::ModuleInstance;
 
 /// A trait for defining the behavior of a Hermes event.
-pub trait HermesEventPayload {
+pub trait HermesEventPayload: Send {
     /// Returns the name of the event associated with the payload.
     fn event_name(&self) -> &str;
 
@@ -16,5 +16,5 @@ pub trait HermesEventPayload {
     /// # Returns
     ///
     /// An `anyhow::Result` indicating the success or failure of the payload execution.
-    fn execute(&self, executor: &mut ModuleInstance) -> anyhow::Result<()>;
+    fn execute(&self, module: &mut ModuleInstance) -> anyhow::Result<()>;
 }

hermes/bin/src/lib.rs

@@ -2,6 +2,6 @@
 //! This file exists, so that doc tests can be used inside binary crates.
 
 mod event_queue;
-mod runtime;
+mod runtime_extensions;
 mod state;
 mod wasm;

hermes/bin/src/main.rs

@@ -1,7 +1,7 @@
 //! The Hermes Node.
 
 mod event_queue;
-mod runtime;
+mod runtime_extensions;
 mod state;
 mod wasm;
 

hermes/bin/src/runtime_extensions/hermes/binary/host.rs

@@ -0,0 +1,5 @@
+//! Binary host implementation for WASM runtime.
+
+use crate::{runtime_extensions::bindings::hermes::binary::api::Host, state::HermesState};
+
+impl Host for HermesState {}

hermes/bin/src/runtime_extensions/hermes/binary/mod.rs

@@ -0,0 +1,14 @@
+//! Binary runtime extension implementation.
+
+use crate::runtime_extensions::state::{Context, Stateful};
+
+mod host;
+
+/// State
+pub(crate) struct State {}
+
+impl Stateful for State {
+    fn new(_ctx: &Context) -> Self {
+        State {}
+    }
+}

hermes/bin/src/runtime_extensions/hermes/cardano/event.rs

@@ -0,0 +1,87 @@
+//! Cardano Blockchain runtime extension event handler implementation.
+
+use crate::{
+    event_queue::event::HermesEventPayload,
+    runtime_extensions::bindings::hermes::cardano::api::{
+        BlockSrc, CardanoBlock, CardanoBlockchainId, CardanoTxn,
+    },
+};
+
+/// On Cardano block event
+struct OnCardanoBlockEvent {
+    /// The blockchain id the block originated from.
+    blockchain: CardanoBlockchainId,
+    /// This raw CBOR block data.
+    block: CardanoBlock,
+    /// Source information about where the block came from, and if we are at tip or not.
+    source: BlockSrc,
+}
+
+impl HermesEventPayload for OnCardanoBlockEvent {
+    fn event_name(&self) -> &str {
+        "on-cardano-block"
+    }
+
+    fn execute(&self, module: &mut crate::wasm::module::ModuleInstance) -> anyhow::Result<()> {
+        module
+            .instance
+            .hermes_cardano_event_on_block()
+            .call_on_cardano_block(&mut module.store, self.blockchain, &self.block, self.source)?;
+        Ok(())
+    }
+}
+
+/// On Cardano txn event
+struct OnCardanoTxnEvent {
+    /// The blockchain id the block originated from.
+    blockchain: CardanoBlockchainId,
+    /// The slot the transaction is in.
+    slot: u64,
+    /// The offset in the block this transaction is at.
+    txn_index: u32,
+    /// The raw transaction data itself.
+    txn: CardanoTxn,
+}
+
+impl HermesEventPayload for OnCardanoTxnEvent {
+    fn event_name(&self) -> &str {
+        "on-cardano-txn"
+    }
+
+    fn execute(&self, module: &mut crate::wasm::module::ModuleInstance) -> anyhow::Result<()> {
+        module
+            .instance
+            .hermes_cardano_event_on_txn()
+            .call_on_cardano_txn(
+                &mut module.store,
+                self.blockchain,
+                self.slot,
+                self.txn_index,
+                &self.txn,
+            )?;
+
+        Ok(())
+    }
+}
+
+/// On Cardano rollback event
+struct OnCardanoRollback {
+    /// The blockchain id the block originated from.
+    blockchain: CardanoBlockchainId,
+    /// The slot the transaction is in.
+    slot: u64,
+}
+
+impl HermesEventPayload for OnCardanoRollback {
+    fn event_name(&self) -> &str {
+        "on-cardano-rollback"
+    }
+
+    fn execute(&self, module: &mut crate::wasm::module::ModuleInstance) -> anyhow::Result<()> {
+        module
+            .instance
+            .hermes_cardano_event_on_rollback()
+            .call_on_cardano_rollback(&mut module.store, self.blockchain, self.slot)?;
+        Ok(())
+    }
+}

hermes/bin/src/runtime/host/hermes/cardano/mod.rs → hermes/bin/src/runtime_extensions/hermes/cardano/host.rs

@@ -1,25 +1,13 @@
-//! Host - Cardano Blockchain implementations
+//!  Cardano Blockchain host implementation for WASM runtime.
 
 use crate::{
-    runtime::extensions::{
-        bindings::hermes::cardano::api::{
-            CardanoBlock, CardanoBlockchainId, CardanoTxn, FetchError, Host, Slot, TxnError,
-            UnsubscribeOptions,
-        },
-        state::{Context, Stateful},
+    runtime_extensions::bindings::hermes::cardano::api::{
+        CardanoBlock, CardanoBlockchainId, CardanoTxn, FetchError, Host, Slot, TxnError,
+        UnsubscribeOptions,
     },
     state::HermesState,
 };
 
-/// State
-pub(crate) struct State {}
-
-impl Stateful for State {
-    fn new(_ctx: &Context) -> Self {
-        State {}
-    }
-}
-
 impl Host for HermesState {
     /// Subscribe to the Blockchain block data.
     ///

hermes/bin/src/runtime_extensions/hermes/cardano/mod.rs

@@ -0,0 +1,15 @@
+//! Cardano Blockchain runtime extension implementation.
+
+use crate::runtime_extensions::state::{Context, Stateful};
+
+mod event;
+mod host;
+
+/// State
+pub(crate) struct State {}
+
+impl Stateful for State {
+    fn new(_ctx: &Context) -> Self {
+        State {}
+    }
+}

hermes/bin/src/runtime_extensions/hermes/cbor/host.rs

@@ -0,0 +1,5 @@
+//! CBOR host implementation for WASM runtime.
+
+use crate::{runtime_extensions::bindings::hermes::cbor::api::Host, state::HermesState};
+
+impl Host for HermesState {}

hermes/bin/src/runtime_extensions/hermes/cbor/mod.rs

@@ -0,0 +1,14 @@
+//! CBOR runtime extension implementation.
+
+use crate::runtime_extensions::state::{Context, Stateful};
+
+mod host;
+
+/// State
+pub(crate) struct State {}
+
+impl Stateful for State {
+    fn new(_ctx: &Context) -> Self {
+        State {}
+    }
+}

hermes/bin/src/runtime_extensions/hermes/cron/event.rs

@@ -0,0 +1,30 @@
+//! Cron runtime extension event handler implementation.
+
+use crate::{
+    event_queue::event::HermesEventPayload,
+    runtime_extensions::bindings::hermes::cron::api::CronTagged,
+};
+
+/// On cron event
+struct OnCronEvent {
+    /// The tagged cron event that was triggered.
+    tag: CronTagged,
+    /// This cron event will not retrigger.
+    last: bool,
+}
+
+impl HermesEventPayload for OnCronEvent {
+    fn event_name(&self) -> &str {
+        "on-cron"
+    }
+
+    fn execute(&self, module: &mut crate::wasm::module::ModuleInstance) -> anyhow::Result<()> {
+        // TODO (@stevenj): https://github.com/input-output-hk/hermes/issues/93
+        let _res: bool = module.instance.hermes_cron_event().call_on_cron(
+            &mut module.store,
+            &self.tag,
+            self.last,
+        )?;
+        Ok(())
+    }
+}

hermes/bin/src/runtime/host/hermes/cron/mod.rs → hermes/bin/src/runtime_extensions/hermes/cron/host.rs

@@ -1,25 +1,13 @@
-//! Host - Cron implementations
+//! Cron host implementation for WASM runtime.
 
 use crate::{
-    runtime::extensions::{
-        bindings::{
-            hermes::cron::api::{CronEventTag, CronSched, CronTagged, CronTime, Host},
-            wasi::clocks::monotonic_clock::Instant,
-        },
-        state::{Context, Stateful},
+    runtime_extensions::bindings::{
+        hermes::cron::api::{CronEventTag, CronSched, CronTagged, CronTime, Host},
+        wasi::clocks::monotonic_clock::Instant,
     },
     state::HermesState,
 };
 
-/// State
-pub(crate) struct State {}
-
-impl Stateful for State {
-    fn new(_ctx: &Context) -> Self {
-        State {}
-    }
-}
-
 impl Host for HermesState {
     /// # Schedule Recurrent CRON event
     ///

hermes/bin/src/runtime_extensions/hermes/cron/mod.rs

@@ -0,0 +1,15 @@
+//! Cron runtime extension implementation.
+
+use crate::runtime_extensions::state::{Context, Stateful};
+
+mod event;
+mod host;
+
+/// State
+pub(crate) struct State {}
+
+impl Stateful for State {
+    fn new(_ctx: &Context) -> Self {
+        State {}
+    }
+}

hermes/bin/src/runtime/host/hermes/crypto/mod.rs → hermes/bin/src/runtime_extensions/hermes/crypto/host.rs

@@ -1,28 +1,16 @@
-//! Host - Crypto implementations
+//! Crypto host implementation for WASM runtime.
 
 use crate::{
-    runtime::extensions::{
-        bindings::hermes::{
-            binary::api::Bstr,
-            crypto::api::{
-                Ed25519Bip32, Ed25519Bip32PrivateKey, Ed25519Bip32PublicKey, Ed25519Bip32Signature,
-                Host, HostEd25519Bip32,
-            },
+    runtime_extensions::bindings::hermes::{
+        binary::api::Bstr,
+        crypto::api::{
+            Ed25519Bip32, Ed25519Bip32PrivateKey, Ed25519Bip32PublicKey, Ed25519Bip32Signature,
+            Host, HostEd25519Bip32,
         },
-        state::{Context, Stateful},
     },
     state::HermesState,
 };
 
-/// State
-pub(crate) struct State {}
-
-impl Stateful for State {
-    fn new(_ctx: &Context) -> Self {
-        State {}
-    }
-}
-
 impl HostEd25519Bip32 for HermesState {
     /// Create a new ED25519-BIP32 Crypto resource
     ///