Add message compression and versioning

bindings/wasm/docs/api-reference.md

@@ -42,6 +42,8 @@
 ## Members
 
 <dl>
+<dt><a href="#DIDMessageEncoding">DIDMessageEncoding</a></dt>
+<dd></dd>
 <dt><a href="#Digest">Digest</a></dt>
 <dd></dd>
 <dt><a href="#KeyType">KeyType</a></dt>
@@ -211,6 +213,7 @@ Creates a new `Client` with default settings for the given `Network`.
     * _instance_
         * [.setNetwork(network)](#Config+setNetwork)
         * [.setNode(url)](#Config+setNode)
+        * [.setEncoding(encoding)](#Config+setEncoding)
         * [.setPrimaryNode(url, jwt, username, password)](#Config+setPrimaryNode)
         * [.setPrimaryPoWNode(url, jwt, username, password)](#Config+setPrimaryPoWNode)
         * [.setPermanode(url, jwt, username, password)](#Config+setPermanode)
@@ -244,6 +247,15 @@ Creates a new `Client` with default settings for the given `Network`.
 | --- | --- |
 | url | <code>string</code> | 
 
+<a name="Config+setEncoding"></a>
+
+### config.setEncoding(encoding)
+**Kind**: instance method of [<code>Config</code>](#Config)  
+
+| Param | Type |
+| --- | --- |
+| encoding | <code>number</code> | 
+
 <a name="Config+setPrimaryNode"></a>
 
 ### config.setPrimaryNode(url, jwt, username, password)
@@ -1757,6 +1769,10 @@ Deserializes a `VerificationMethod` object from a JSON object.
 | --- | --- |
 | value | <code>any</code> | 
 
+<a name="DIDMessageEncoding"></a>
+
+## DIDMessageEncoding
+**Kind**: global variable  
 <a name="Digest"></a>
 
 ## Digest

bindings/wasm/examples/src/private_tangle.js

@@ -1,7 +1,7 @@
 // Copyright 2020-2021 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-import {Client, Config, Document, KeyPair, KeyType, Network} from '@iota/identity-wasm';
+import {Client, Config, Document, KeyPair, KeyType, Network, DIDMessageEncoding} from '@iota/identity-wasm';
 
 /**
     This example shows how a DID document can be created on a private tangle.
@@ -32,6 +32,9 @@ async function createIdentityPrivateTangle(restURL, networkName) {
     // This URL points to the REST API of the locally running hornet node.
     config.setNode(restURL || "http://127.0.0.1:14265/");
 
+    // Use DIDMessageEncoding.Json instead to publish plaintext messages to the Tangle for debugging.
+    config.setEncoding(DIDMessageEncoding.JsonBrotli);
+
     // Create a client instance from the configuration to publish messages to the Tangle.
     const client = Client.fromConfig(config);
 

bindings/wasm/src/tangle/config.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 use wasm_bindgen::prelude::*;
 
 use crate::error::wasm_error;
+use crate::tangle::WasmDIDMessageEncoding;
 use crate::tangle::WasmNetwork;
 
 fn to_duration(seconds: u32) -> Duration {
@@ -48,6 +49,11 @@ impl Config {
     self.try_with_mut(|builder| builder.node(url).map_err(wasm_error))
   }
 
+  #[wasm_bindgen(js_name = setEncoding)]
+  pub fn set_encoding(&mut self, encoding: WasmDIDMessageEncoding) -> Result<(), JsValue> {
+    self.with_mut(|builder| builder.encoding(encoding.into()))
+  }
+
   #[wasm_bindgen(js_name = setPrimaryNode)]
   pub fn set_primary_node(
     &mut self,

bindings/wasm/src/tangle/message.rs

@@ -0,0 +1,30 @@
+// Copyright 2020-2021 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use identity::iota::DIDMessageEncoding;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = DIDMessageEncoding)]
+#[derive(Copy, Clone, Debug)]
+pub enum WasmDIDMessageEncoding {
+  Json = 0,
+  JsonBrotli = 1,
+}
+
+impl From<DIDMessageEncoding> for WasmDIDMessageEncoding {
+  fn from(encoding: DIDMessageEncoding) -> Self {
+    match encoding {
+      DIDMessageEncoding::Json => Self::Json,
+      DIDMessageEncoding::JsonBrotli => Self::JsonBrotli,
+    }
+  }
+}
+
+impl From<WasmDIDMessageEncoding> for DIDMessageEncoding {
+  fn from(encoding: WasmDIDMessageEncoding) -> Self {
+    match encoding {
+      WasmDIDMessageEncoding::Json => Self::Json,
+      WasmDIDMessageEncoding::JsonBrotli => Self::JsonBrotli,
+    }
+  }
+}

bindings/wasm/src/tangle/mod.rs

@@ -3,8 +3,10 @@
 
 pub use self::client::*;
 pub use self::config::*;
+pub use self::message::*;
 pub use self::network::*;
 
 mod client;
 mod config;
+mod message;
 mod network;

examples/low-level-api/private_tangle.rs

@@ -10,6 +10,7 @@
 //! cargo run --example private_tangle
 
 use identity::iota::ClientBuilder;
+use identity::iota::DIDMessageEncoding;
 use identity::iota::IotaDID;
 use identity::iota::Network;
 use identity::iota::Receipt;
@@ -34,8 +35,12 @@ pub async fn main() -> Result<()> {
   // In a locally running one-click tangle, this would often be `http://127.0.0.1:14265/`
   let private_node_url = "https://api.lb-0.h.chrysalis-devnet.iota.cafe";
 
+  // Use DIDMessageEncoding::Json instead to publish plaintext messages to the Tangle for debugging.
+  let encoding = DIDMessageEncoding::JsonBrotli;
+
   let client = ClientBuilder::new()
     .network(network.clone())
+    .encoding(encoding)
     .node(private_node_url)?
     .build()
     .await?;

identity-iota/Cargo.toml

@@ -12,6 +12,7 @@ description = "An IOTA Tangle intergration for the identity-rs library."
 
 [dependencies]
 async-trait = { version = "0.1", default-features = false }
+brotli = { version = "3.3", default-features = false, features = ["std"] }
 dashmap = { version = "4.0" }
 form_urlencoded = { version = "1.0" }
 futures = { version = "0.3" }
@@ -20,6 +21,8 @@ identity-credential = { version = "=0.4.0", path = "../identity-credential" }
 identity-did = { version = "=0.4.0", path = "../identity-did" }
 lazy_static = { version = "1.4", default-features = false }
 log = { version = "0.4", default-features = false }
+num-derive = { version = "0.3", default-features = false }
+num-traits = { version = "0.2", default-features = false, features = ["std"] }
 serde = { version = "1.0", default-features = false, features = ["std", "derive"] }
 strum = { version = "0.21", features = ["derive"] }
 thiserror = { version = "1.0", default-features = false }

identity-iota/src/error.rs

@@ -53,4 +53,8 @@ pub enum Error {
   NoExplorerURLSet,
   #[error("Invalid Explorer Url")]
   InvalidExplorerURL,
+  #[error("compression error")]
+  CompressionError,
+  #[error("invalid message flags")]
+  InvalidMessageFlags,
 }

identity-iota/src/tangle/client.rs

@@ -18,6 +18,7 @@ use crate::did::IotaDocument;
 use crate::error::Error;
 use crate::error::Result;
 use crate::tangle::ClientBuilder;
+use crate::tangle::DIDMessageEncoding;
 use crate::tangle::Message;
 use crate::tangle::MessageId;
 use crate::tangle::Network;
@@ -30,6 +31,7 @@ use crate::tangle::TangleResolve;
 pub struct Client {
   pub(crate) client: IotaClient,
   pub(crate) network: Network,
+  pub(crate) encoding: DIDMessageEncoding,
 }
 
 impl Client {
@@ -65,6 +67,7 @@ impl Client {
     Ok(Self {
       client: client.finish().await?,
       network: builder.network,
+      encoding: builder.encoding,
     })
   }
 
@@ -84,13 +87,14 @@ impl Client {
     self.publish_json(&IotaDocument::diff_index(message_id)?, diff).await
   }
 
-  /// Publishes arbitrary JSON data to the specified index on the Tangle.
+  /// Compresses and publishes arbitrary JSON data to the specified index on the Tangle.
   pub async fn publish_json<T: ToJson>(&self, index: &str, data: &T) -> Result<Receipt> {
+    let message_data: Vec<u8> = crate::tangle::pack_did_message(data, self.encoding)?;
     self
       .client
       .message()
       .with_index(index)
-      .with_data(data.to_json_vec()?)
+      .with_data(message_data)
       .finish()
       .await
       .map_err(Into::into)

identity-iota/src/tangle/client_builder.rs

@@ -8,6 +8,7 @@ use std::time::Duration;
 
 use crate::error::Result;
 use crate::tangle::Client;
+use crate::tangle::DIDMessageEncoding;
 use crate::tangle::Network;
 
 const DEFAULT_LOCAL_POW: bool = false;
@@ -17,6 +18,7 @@ pub struct ClientBuilder {
   pub(super) nodeset: bool,
   pub(super) network: Network,
   pub(super) builder: iota_client::ClientBuilder,
+  pub(super) encoding: DIDMessageEncoding,
 }
 
 impl ClientBuilder {
@@ -26,6 +28,7 @@ impl ClientBuilder {
       nodeset: false,
       network: Default::default(),
       builder: iota_client::ClientBuilder::new().with_local_pow(DEFAULT_LOCAL_POW),
+      encoding: DIDMessageEncoding::JsonBrotli,
     }
   }
 
@@ -36,6 +39,12 @@ impl ClientBuilder {
     self
   }
 
+  /// Sets the DID message encoding used when publishing to the Tangle.
+  pub fn encoding(mut self, encoding: DIDMessageEncoding) -> Self {
+    self.encoding = encoding;
+    self
+  }
+
   /// Adds an IOTA node by its URL.
   pub fn node(mut self, url: &str) -> Result<Self> {
     self.builder = self.builder.with_node(url)?;

identity-iota/src/tangle/message/compression_brotli.rs

@@ -0,0 +1,52 @@
+// Copyright 2020-2021 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use std::io::Read;
+
+use crate::error::Error;
+use crate::error::Result;
+
+const BUFFER_SIZE: usize = 4096;
+const QUALITY: u32 = 5; // compression level
+const WINDOWS_SIZE: u32 = 22;
+
+pub(crate) fn compress_brotli<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>> {
+  let mut buf = Vec::new();
+  let mut compressor = brotli::CompressorReader::new(input.as_ref(), BUFFER_SIZE, QUALITY, WINDOWS_SIZE);
+  compressor.read_to_end(&mut buf).map_err(|_| Error::CompressionError)?;
+  Ok(buf)
+}
+
+pub(crate) fn decompress_brotli<T: AsRef<[u8]> + ?Sized>(input: &T) -> Result<Vec<u8>> {
+  let mut decompressor = brotli::Decompressor::new(input.as_ref(), BUFFER_SIZE);
+  let mut buf = Vec::new();
+  decompressor
+    .read_to_end(&mut buf)
+    .map_err(|_| Error::CompressionError)?;
+  Ok(buf)
+}
+
+#[cfg(test)]
+mod test {
+  use identity_core::convert::ToJson;
+  use identity_core::crypto::KeyPair;
+
+  use crate::did::IotaDocument;
+
+  use super::*;
+
+  #[test]
+  fn test_brotli() {
+    let keypair: KeyPair = KeyPair::new_ed25519().unwrap();
+    let mut document: IotaDocument = IotaDocument::new(&keypair).unwrap();
+    document
+      .sign_self(keypair.private(), &document.default_signing_method().unwrap().id())
+      .unwrap();
+
+    let data = document.to_json().unwrap();
+    let compressed = compress_brotli(data.as_str()).unwrap();
+    let decompressed = decompress_brotli(&compressed).unwrap();
+
+    assert_eq!(decompressed, data.as_bytes());
+  }
+}

identity-iota/src/tangle/message/message_encoding.rs

@@ -0,0 +1,21 @@
+// Copyright 2020-2021 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use num_traits::FromPrimitive;
+
+use crate::Error;
+
+/// Indicates the encoding and compression of a DID Message.
+#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, num_derive::FromPrimitive)]
+pub enum DIDMessageEncoding {
+  Json = 0,
+  JsonBrotli = 1,
+}
+
+impl TryFrom<u8> for DIDMessageEncoding {
+  type Error = Error;
+
+  fn try_from(value: u8) -> Result<Self, Self::Error> {
+    FromPrimitive::from_u8(value).ok_or(Error::InvalidMessageFlags)
+  }
+}