Forward support in WASM (#57)

Forward support in JS

Author: ashcherbakov

src/protocols/routing/forward.rs

@@ -1,7 +1,9 @@
+use serde::Serialize;
 use serde_json::Value;
 
 use crate::Message;
 
+#[derive(Debug, PartialEq, Eq, Serialize, Clone)]
 pub struct ParsedForward<'a> {
     pub msg: &'a Message,
     pub next: String,

wasm/Cargo.toml

@@ -21,6 +21,7 @@ default = ['console_error_panic_hook']
 async-trait = '0.1'
 wasm-bindgen-futures = '0.4'
 js-sys = '0.3'
+serde_json = '1.0'
 
 [dependencies.didcomm]
 path = '..'

wasm/demo/src/advanced-params.ts

@@ -36,7 +36,7 @@ async function main() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
       protect_sender: true,
       enc_alg_anon: "A256cbcHs512EcdhEsA256kw",
       messaging_service: "did:example:bob#didcomm-1",

wasm/demo/src/attachments.ts

@@ -46,7 +46,7 @@ async function main() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
     }
   );
 

wasm/demo/src/main.ts

@@ -7,13 +7,7 @@ import {
   BOB_SECRETS,
 } from "./test-vectors";
 
-import {
-  Message,
-  DIDDoc,
-  DIDResolver,
-  Secret,
-  SecretsResolver,
-} from "didcomm";
+import { Message, DIDDoc, DIDResolver, Secret, SecretsResolver } from "didcomm";
 import {
   CHARLIE_DID,
   CHARLIE_DID_DOC,
@@ -95,7 +89,7 @@ async function nonRepudiableEncryption() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
     }
   );
 
@@ -147,7 +141,7 @@ async function multiRecipient() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
     }
   );
 
@@ -165,7 +159,7 @@ async function multiRecipient() {
       didResolver,
       secretsResolver,
       {
-        forward: false,
+        forward: false, // TODO: should be true by default
       }
     );
 
@@ -236,7 +230,7 @@ async function repudiableAuthentcatedEncryption() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
     }
   );
 
@@ -284,7 +278,7 @@ async function repudiableNonAuthentcatedEncryption() {
     didResolver,
     secretsResolver,
     {
-      forward: false,
+      forward: false, // TODO: should be true by default
     }
   );
 
@@ -388,3 +382,5 @@ async function plaintext() {
 }
 
 main().catch((e) => console.log(e));
+
+// TODO: add examples for Forward (routing) and Mediators

wasm/src/message/mod.rs

@@ -2,6 +2,7 @@ mod from_prior;
 mod pack_encrypted;
 mod pack_plaintext;
 mod pack_signed;
+mod protocols;
 mod unpack;
 
 use didcomm::error::{ErrorKind, ResultExt};

wasm/src/message/protocols/mod.rs

@@ -0,0 +1 @@
+pub mod routing;

wasm/src/message/protocols/routing/mod.rs

@@ -0,0 +1,155 @@
+use std::{collections::HashMap, rc::Rc};
+
+use crate::{did::JsDIDResolver, error::JsResult, DIDResolver};
+use crate::{utils::set_panic_hook, Message};
+use didcomm::{
+    algorithms::AnonCryptAlg,
+    error::{ErrorKind, ResultExt},
+    protocols::routing::{try_parse_forward, wrap_in_forward},
+};
+use js_sys::Promise;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::future_to_promise;
+
+#[wasm_bindgen]
+pub struct ParsedForward(pub(crate) Rc<didcomm::protocols::routing::ParsedForward<'static>>);
+
+#[wasm_bindgen]
+impl ParsedForward {
+    #[wasm_bindgen(skip_typescript)]
+    pub fn as_value(&self) -> Result<JsValue, JsValue> {
+        let msg = JsValue::from_serde(&*self.0)
+            .kind(ErrorKind::Malformed, "Unable serialize ParsedForward")
+            .as_js()?;
+
+        Ok(msg)
+    }
+}
+
+#[wasm_bindgen]
+impl Message {
+    #[wasm_bindgen(skip_typescript)]
+    pub fn wrap_in_forward(
+        msg: String,
+        headers: JsValue,
+        to: String,
+        routing_keys: JsValue,
+        enc_alg_anon: JsValue,
+        did_resolver: DIDResolver,
+    ) -> Promise {
+        // TODO: Better place?
+        set_panic_hook();
+
+        let did_resolver = JsDIDResolver(did_resolver);
+        future_to_promise(async move {
+            let headers: HashMap<String, Value> = headers
+                .into_serde()
+                .kind(ErrorKind::Malformed, "headers param is malformed")
+                .as_js()?;
+
+            let routing_keys: Vec<String> = routing_keys
+                .into_serde()
+                .kind(ErrorKind::Malformed, "routing_keys param is malformed")
+                .as_js()?;
+
+            let enc_alg_anon: AnonCryptAlg = enc_alg_anon
+                .into_serde()
+                .kind(ErrorKind::Malformed, "enc_alg_anon param is malformed")
+                .as_js()?;
+
+            let res = wrap_in_forward(
+                &msg,
+                Some(&headers),
+                &to,
+                &routing_keys,
+                &enc_alg_anon,
+                &did_resolver,
+            )
+            .await
+            .as_js()?;
+
+            Ok(res.into())
+        })
+    }
+
+    #[wasm_bindgen(skip_typescript)]
+    pub fn try_parse_forward(&self) -> Result<JsValue, JsValue> {
+        let msg = self.0.clone();
+        let parsed_message = try_parse_forward(&msg);
+        Ok(JsValue::from_serde(&parsed_message)
+            .kind(
+                ErrorKind::Malformed,
+                "Unable serialize parsed forward message",
+            )
+            .as_js()?)
+    }
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const PARSED_FORWARD_AS_VALUE_TS: &'static str = r#"
+interface ParsedForward {
+    as_value(): IParsedForward;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "IParsedForward")]
+    pub type IParsedForward;
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const IPARSED_FORWARD_TS: &'static str = r#"
+type IParsedForward = {
+    msg: Message,
+    next: string,
+    forwarded_msg: any
+}
+"#;
+
+#[wasm_bindgen(typescript_custom_section)]
+const MESSAGE_WRAP_IN_FORWARD_TS: &'static str = r#"
+export namespace Message {
+    /**
+     * Resolves recipient DID DOC Service and Builds Forward envelops if needed.
+     * 
+     * Wraps the given packed DIDComm message in Forward messages for every routing key.
+     * 
+     * @param msg the message to be wrapped in Forward messages
+     * @param headers optional headers for Forward message
+     * @param to recipient's DID (DID URL)
+     * @param routing_keys list of routing keys
+     * @param enc_alg_anon The encryption algorithm to be used for anonymous encryption (anon_crypt)
+     * @param did_resolver instance of `DIDResolver` to resolve DIDs.
+     * 
+     * @returns a top-level packed Forward message as JSON string
+     * 
+     * @throws DIDCommDIDNotResolved
+     * @throws DIDCommDIDUrlNotFound
+     * @throws DIDCommIoError
+     * @throws DIDCommInvalidState
+     * @throws DIDCommIllegalArgument
+     */
+    function wrap_in_forward(
+        msg: string,
+        headers: Record<string, string>,
+        to: string,
+        routing_keys: Array<string>, 
+        enc_alg_anon: string,
+        did_resolver: DIDResolver,
+    ): Promise<string>;
+}
+"#;
+
+#[wasm_bindgen(typescript_custom_section)]
+const MESSAGE_TRY_PARSE_FORWARD_TS: &'static str = r#"
+interface Message {
+    /**
+     * Tries to parse the Message to a Forward message
+     * 
+     * @returns a parsed message or null
+     */
+    try_parse_forward(): ParsedForward;
+}
+"#;

wasm/tests-js/src/forward/try-parse-forward.test.ts

@@ -0,0 +1,23 @@
+import { Message, ParsedForward } from "didcomm";
+import { MESSAGE_SIMPLE, FORWARD_MESSAGE } from "../test-vectors";
+
+// TODO: more tests
+test.each([
+  {
+    case: "Not Forward",
+    message: MESSAGE_SIMPLE,
+  },
+])("Message.try-parse-forward handles $case", async ({ message }) => {
+  const res = message.try_parse_forward();
+  expect(res).toBeNull();
+});
+
+test.each([
+  {
+    case: "Forward",
+    message: FORWARD_MESSAGE,
+  },
+])("Message.try-parse-forward handles $case", async ({ message }) => {
+  const res = message.try_parse_forward();
+  expect(res).toEqual(expect.anything());
+});

wasm/tests-js/src/forward/wrap-in-forward.test.ts

@@ -0,0 +1,42 @@
+import { Message } from "didcomm";
+import {
+  IMESSAGE_SIMPLE,
+  ExampleDIDResolver,
+  ALICE_DID_DOC,
+  BOB_DID_DOC,
+  ALICE_DID,
+} from "../test-vectors";
+
+// TODO: more tests
+test.each([
+  {
+    case: "Simple",
+    message: IMESSAGE_SIMPLE,
+    headers: { header1: "aaa", header2: "bbb" },
+    to: ALICE_DID,
+    routing_keys: ["did:example:bob#key-x25519-1"],
+    enc_alg_anon: "A256cbcHs512EcdhEsA256kw",
+    did_resolver: new ExampleDIDResolver([ALICE_DID_DOC, BOB_DID_DOC]),
+  },
+])(
+  "Message.wrap-in-forward handles $case",
+  async ({
+    message,
+    headers,
+    to,
+    routing_keys,
+    enc_alg_anon,
+    did_resolver,
+  }) => {
+    const res = await Message.wrap_in_forward(
+      JSON.stringify(message),
+      headers,
+      to,
+      routing_keys,
+      enc_alg_anon,
+      did_resolver
+    );
+    expect(typeof res).toStrictEqual("string");
+    expect(res).toContain("ciphertext");
+  }
+);

wasm/tests-js/src/test-vectors/message.ts

@@ -36,3 +36,45 @@ export const IMESSAGE_FROM_PRIOR = {
 };
 
 export const MESSAGE_FROM_PRIOR = new Message(IMESSAGE_FROM_PRIOR);
+
+export const IFORWARD_MESSAGE = {
+  id: "8404000a-1c6d-4c8c-8c60-e383128d9677",
+  typ: "application/didcomm-plain+json",
+  type: "https://didcomm.org/routing/2.0/forward",
+  body: {
+    next: "did:example:bob",
+  },
+  attachments: [
+    {
+      data: {
+        json: {
+          ciphertext:
+            "ajYDBYyuuftb0f-pCj9iz7uhSJFK95F_WsXcXSKN2HrfPdojdRb9Ss_xI0zJnTC97yRmO9vmfyR8-MkQ_1gh-KyEHZe6UTM7JWpSWC9onReNLTOLaMoM09W8Fb45ZFbqaqZ1Kt3qvKIXEu2BwrZ2jLRu7r2Lo-cDJhDwzhHux27gd-j9Dhvtct3B2AMzXdu2J4fLqIdz9h0XkiI3PB4tLYsgY6KwDMtLyePDbb747bqViqWoBFgDLX2zgL3R9Okxt7RG4-1vqRHfURgcONofWMpFHEFq3WaplipogvuwouP3hJv3OMppBz2KTo1ULg3WWAdrac7laa2XQ6UE1PUo6Cq7IH7mdVoZwRc2v__swib6_WLTZMTW",
+          iv: "hC-Frpywx0Pix6Lak-Rwlpw0IbG28rGo",
+          protected:
+            "eyJ0eXAiOiJhcHBsaWNhdGlvbi9kaWRjb21tLWVuY3J5cHRlZCtqc29uIiwiYWxnIjoiRUNESC1FUytBMjU2S1ciLCJlbmMiOiJYQzIwUCIsImFwdiI6Ik5jc3VBbnJSZlBLNjlBLXJrWjBMOVhXVUc0ak12TkMzWmc3NEJQejUzUEEiLCJlcGsiOnsiY3J2IjoiWDI1NTE5Iiwia3R5IjoiT0tQIiwieCI6Ikg0QURobjA0S1VnX1dXQWpiR0s3eTJ3QkQtTmtsbUhXa0lHUl9jeGtKMXcifX0",
+          recipients: [
+            {
+              encrypted_key:
+                "Bjk-DOK_2omU_LN13TEGs3WBAwWaimaAQVvtIdE4mmCW83M8kOWKfw",
+              header: { kid: "did:example:bob#key-x25519-1" },
+            },
+            {
+              encrypted_key:
+                "SuPR0JolzyGPeNiaj9EoD822TsHXRLJbkyQgOnF_MG-DfPdQ5y2Eeg",
+              header: { kid: "did:example:bob#key-x25519-2" },
+            },
+            {
+              encrypted_key:
+                "6H5qA6Hic0L2B_lzg6q37VbkmHoi8d82seRxswtXp9c1FpTg8cG76w",
+              header: { kid: "did:example:bob#key-x25519-3" },
+            },
+          ],
+          tag: "j4VLGYCa70LhHyDDLUDzKw",
+        },
+      },
+    },
+  ],
+};
+
+export const FORWARD_MESSAGE = new Message(IFORWARD_MESSAGE);