Feat/integrate comms

.changes/config.json

@@ -151,7 +151,7 @@
         "snapshot",
         "random",
         "primitives",
-        "test-utils"
+        "utils"
       ]
     },
     "stronghold-engine": {
@@ -171,7 +171,10 @@
     },
     "stronghold-communication": {
       "path": "./communication/",
-      "manager": "rust"
+      "manager": "rust",
+      "dependencies": [
+        "utils"
+      ]
     },
     "crypto": {
       "path": "./engine/crypto/",
@@ -185,7 +188,7 @@
       "dependencies": [
         "crypto",
         "random",
-        "test-utils"
+        "utils"
       ]
     },
     "snapshot": {
@@ -195,7 +198,7 @@
       "dependencies": [
         "crypto",
         "random",
-        "test-utils"
+        "utils"
       ]
     },
     "random": {
@@ -213,8 +216,8 @@
       "manager": "rust",
       "publish": false
     },
-    "test-utils": {
-      "path": "./test-utils/",
+    "utils": {
+      "path": "./utils/",
       "manager": "rust",
       "publish": false
     }

.changes/integrate_communication.md

@@ -0,0 +1,12 @@
+---
+"stronghold-communication": minor
+"iota-stronghold": minor
+"random": patch
+"snapshot": patch
+"vault": patch
+"stronghold-utils": minor
+---
+
+Refactor the communication actor, enable using a relay peer, and integrate communication as feature into the stronghold interface. 
+Remove unecessary Option/ Result wraps in `random` and `iota-stronghold`.
+Rename stronghold-test-utils to stronghold-utils and added riker ask pattern to it.

.changes/readme.md

@@ -15,7 +15,7 @@
 | random | Engine's Random | Rust | No | No |
 | primitives | Engine's Crypto Primitives | Rust | No | No |
 | store | Engine's Readable Storage Interface | Rust | No | No |
-| test-utils | Internal Dev Utilities for Testing | Rust | No | No |
+| stronghold-utils | Reoccuring Patterns, and Utilities for Testing | Rust | No | No |
 
 As you create PRs and make changes that require a version bump, please add a new markdown file in this folder. You do not note the version _number_, but rather the type of bump that you expect: major, minor, or patch. The filename is not important, as long as it is a `.md`, but we recommend it represents the overall change for our sanity.
 

.github/dependabot.yml

@@ -25,7 +25,7 @@ updates:
     open-pull-requests-limit: 3
 
   - package-ecosystem: "cargo"
-    directory: "/test_utils"
+    directory: "/utils"
     schedule:
       interval: "daily"
     open-pull-requests-limit: 3

Cargo.toml

@@ -10,7 +10,7 @@ members = [
   "runtime",
   "client",
   "communication",
-  "test_utils",
+  "utils",
 ]
 exclude = [
   "products/commandline",

client/Cargo.toml

@@ -22,7 +22,8 @@ zeroize_derive = "1.0"
 anyhow = "1.0"
 thiserror = "1.0"
 futures = "0.3"
-riker = "0.4"
+riker = { version = "0.4", git ="https://github.com/elenaf9/riker", branch = "master" }
+
 
 [dependencies.stronghold-engine]
 path = "../engine"
@@ -39,16 +40,23 @@ features = [ "random", "ed25519", "sha", "hmac", "bip39-en" ]
 version = "*"
 # Note: We are only adding a version so that we can publish to crates.io
 
+[dependencies.stronghold-communication]
+path = "../communication"
+optional = true
+
+[dependencies.stronghold-utils]
+path = "../utils"
+version = "0.1"
+
+[features]
+communication = ["stronghold-communication"]
+
 [dev-dependencies]
 hex = "0.4.2"
 criterion = "0.3.3"
 clap = { version = "3.0.0-beta.1", features = [ "yaml" ] }
 rand = "0.8.3"
 
-[dev-dependencies.stronghold-test-utils]
-path = "../test_utils"
-version = "0.1"
-
 [[bench]]
 name = "benchmark"
 harness = false

client/src/actors/client.rs

@@ -10,13 +10,18 @@ use crate::{
 };
 
 use engine::{snapshot, vault::RecordHint};
+use serde::{Deserialize, Serialize};
 
 use riker::actors::*;
 
+use core::{
+    array::TryFromSliceError,
+    convert::{TryFrom, TryInto},
+};
 use std::{path::PathBuf, time::Duration};
 
 /// `SLIP10DeriveInput` type used to specify a Seed location or a Key location for the `SLIP10Derive` procedure.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum SLIP10DeriveInput {
     /// Note that BIP39 seeds are allowed to be used as SLIP10 seeds
     Seed(Location),
@@ -25,7 +30,7 @@ pub enum SLIP10DeriveInput {
 
 /// Procedure type used to call to the runtime via `Strongnhold.runtime_exec(...)`.
 #[allow(dead_code)]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Procedure {
     /// Generate a raw SLIP10 seed of the specified size (in bytes, defaults to 64 bytes/512 bits) and store it in the
     /// `output` location
@@ -76,7 +81,9 @@ pub enum Procedure {
 /// A Procedure return result type.  Contains the different return values for the `Procedure` type calls used with
 /// `Stronghold.runtime_exec(...)`.
 #[allow(dead_code)]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "SerdeProcResult")]
+#[serde(into = "SerdeProcResult")]
 pub enum ProcResult {
     /// Return from generating a `SLIP10` seed.
     SLIP10Generate(StatusMessage),
@@ -94,8 +101,74 @@ pub enum ProcResult {
     Ed25519Sign(ResultMessage<[u8; crypto::ed25519::SIGNATURE_LENGTH]>),
 }
 
+impl TryFrom<SerdeProcResult> for ProcResult {
+    type Error = TryFromSliceError;
+
+    fn try_from(serde_proc_result: SerdeProcResult) -> Result<Self, Self::Error> {
+        match serde_proc_result {
+            SerdeProcResult::SLIP10Generate(msg) => Ok(ProcResult::SLIP10Generate(msg)),
+            SerdeProcResult::SLIP10Derive(msg) => Ok(ProcResult::SLIP10Derive(msg)),
+            SerdeProcResult::BIP39Recover(msg) => Ok(ProcResult::BIP39Recover(msg)),
+            SerdeProcResult::BIP39Generate(msg) => Ok(ProcResult::BIP39Generate(msg)),
+            SerdeProcResult::BIP39MnemonicSentence(msg) => Ok(ProcResult::BIP39MnemonicSentence(msg)),
+            SerdeProcResult::Ed25519PublicKey(msg) => {
+                let msg: ResultMessage<[u8; crypto::ed25519::COMPRESSED_PUBLIC_KEY_LENGTH]> = match msg {
+                    ResultMessage::Ok(v) => ResultMessage::Ok(v.as_slice().try_into()?),
+                    ResultMessage::Error(e) => ResultMessage::Error(e),
+                };
+                Ok(ProcResult::Ed25519PublicKey(msg))
+            }
+            SerdeProcResult::Ed25519Sign(msg) => {
+                let msg: ResultMessage<[u8; crypto::ed25519::SIGNATURE_LENGTH]> = match msg {
+                    ResultMessage::Ok(v) => ResultMessage::Ok(v.as_slice().try_into()?),
+                    ResultMessage::Error(e) => ResultMessage::Error(e),
+                };
+                Ok(ProcResult::Ed25519Sign(msg))
+            }
+        }
+    }
+}
+
+// Replaces arrays in ProcResult with vectors to derive Serialize/ Deserialize
+#[derive(Clone, Serialize, Deserialize)]
+enum SerdeProcResult {
+    SLIP10Generate(StatusMessage),
+    SLIP10Derive(ResultMessage<hd::ChainCode>),
+    BIP39Recover(StatusMessage),
+    BIP39Generate(StatusMessage),
+    BIP39MnemonicSentence(ResultMessage<String>),
+    Ed25519PublicKey(ResultMessage<Vec<u8>>),
+    Ed25519Sign(ResultMessage<Vec<u8>>),
+}
+
+impl From<ProcResult> for SerdeProcResult {
+    fn from(proc_result: ProcResult) -> Self {
+        match proc_result {
+            ProcResult::SLIP10Generate(msg) => SerdeProcResult::SLIP10Generate(msg),
+            ProcResult::SLIP10Derive(msg) => SerdeProcResult::SLIP10Derive(msg),
+            ProcResult::BIP39Recover(msg) => SerdeProcResult::BIP39Recover(msg),
+            ProcResult::BIP39Generate(msg) => SerdeProcResult::BIP39Generate(msg),
+            ProcResult::BIP39MnemonicSentence(msg) => SerdeProcResult::BIP39MnemonicSentence(msg),
+            ProcResult::Ed25519PublicKey(msg) => {
+                let msg = match msg {
+                    ResultMessage::Ok(slice) => ResultMessage::Ok(slice.to_vec()),
+                    ResultMessage::Error(error) => ResultMessage::Error(error),
+                };
+                SerdeProcResult::Ed25519PublicKey(msg)
+            }
+            ProcResult::Ed25519Sign(msg) => {
+                let msg = match msg {
+                    ResultMessage::Ok(slice) => ResultMessage::Ok(slice.to_vec()),
+                    ResultMessage::Error(error) => ResultMessage::Error(error),
+                };
+                SerdeProcResult::Ed25519Sign(msg)
+            }
+        }
+    }
+}
+
 #[allow(dead_code)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum SHRequest {
     // check if vault exists.
     CheckVault(Vec<u8>),
@@ -173,7 +246,7 @@ pub enum SHRequest {
 }
 
 /// Messages that come from stronghold
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum SHResults {
     ReturnWriteStore(StatusMessage),
     ReturnReadStore(Vec<u8>, StatusMessage),

client/src/bucket.rs

@@ -203,29 +203,26 @@ impl<P: BoxProvider + Send + Sync + Clone + Ord + PartialOrd + PartialEq + Eq +
 
     /// Exposes the `DBView` of the current vault and the cache layer to allow transactions to occur.
     fn take(&mut self, key: Key<P>, f: impl FnOnce(DBView<P>, Vec<ReadResult>) -> Vec<ReadResult>) {
-        let mut _reads = self.get_reads(key.clone());
-        let reads = _reads.take().expect(line_error!());
-        let mut _view = self.get_view(key.clone(), reads.clone());
-        let view = _view.take().expect(line_error!());
+        let reads = self.get_reads(key.clone());
+        let view = self.get_view(key.clone(), reads.clone());
         let res = f(view, reads);
         self.insert_reads(key.clone(), res);
-        self.insert_view(key, _view);
+        self.insert_view(key, None);
     }
 
-    fn get_view(&mut self, key: Key<P>, reads: Vec<ReadResult>) -> Option<DBView<P>> {
+    fn get_view(&mut self, key: Key<P>, reads: Vec<ReadResult>) -> DBView<P> {
         self.vaults.remove(&key);
-
-        Some(DBView::load(key, reads.iter()).expect(line_error!()))
+        DBView::load(key, reads.iter()).expect(line_error!())
     }
 
     fn insert_view(&mut self, key: Key<P>, view: Option<DBView<P>>) {
         self.vaults.insert(key, view);
     }
 
-    fn get_reads(&mut self, key: Key<P>) -> Option<Vec<ReadResult>> {
+    fn get_reads(&mut self, key: Key<P>) -> Vec<ReadResult> {
         match self.cache.remove(&key) {
-            Some(reads) => Some(reads),
-            None => Some(Vec::<ReadResult>::new()),
+            Some(reads) => reads,
+            None => Vec::<ReadResult>::new(),
         }
     }