Add wasm foundation

.gitignore

@@ -20,4 +20,11 @@ Cargo.lock
 
 # Do not put native binaries in source control
 bound/kt/src/main/resources/*.dylib
-bound/kt/src/main/resources/*.so
+bound/kt/src/main/resources/*.so
+
+LICENSE
+.vscode/
+bound/typescript/dist/*
+!bound/typescript/dist/index.js
+bound/typescript/tests/compiled
+bound/typescript/src/wasm/generated.js

Cargo.toml

@@ -1,13 +1,12 @@
 [workspace]
-members = [ 
-    "crates/web5", 
-    "crates/web5_cli", 
-    "bindings/web5_uniffi", 
-    "bindings/web5_uniffi_wrapper", 
-]
-default-members = [
+members = [
+    "bindings/web5_uniffi",
+    "bindings/web5_uniffi_wrapper",
+    "bindings/web5_wasm",
     "crates/web5",
+    "crates/web5_cli",
 ]
+default-members = ["crates/web5"]
 resolver = "2"
 
 [workspace.package]

Justfile

@@ -8,9 +8,12 @@ setup:
     git submodule update --init --recursive
   fi
   if [[ "$(cargo 2>&1)" == *"rustup could not choose a version of cargo to run"* ]]; then
-    rustup default 1.74.0
+    rustup default 1.76.0 # TODO undo this
     rustup target add aarch64-apple-darwin
   fi
+  if ! command -v wasm-pack >/dev/null || [[ "$(wasm-pack --version)" != "wasm-pack 0.13.0" ]]; then
+    cargo install wasm-pack --version 0.13.0
+  fi
 
 docs: setup
   cargo doc --open --no-deps
@@ -46,3 +49,6 @@ test-bound: setup
 
 test-kotlin: setup
   cd bound/kt && mvn clean test
+
+wasm: setup
+  (cd bindings/web5_wasm; wasm-pack build --target nodejs --out-dir ../../bound/typescript/pkg)

bin/corepack

@@ -1 +1 @@
-.node-20.9.0.pkg
+.node-20.15.1.pkg

bin/node

@@ -1 +1 @@
-.node-20.9.0.pkg
+.node-20.15.1.pkg

bin/npm

@@ -1 +1 @@
-.node-20.9.0.pkg
+.node-20.15.1.pkg

bin/npx

@@ -1 +1 @@
-.node-20.9.0.pkg
+.node-20.15.1.pkg

bindings/web5_wasm/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "web5_wasm"
+version = "0.1.0"
+edition = "2021"
+homepage.workspace = true
+repository.workspace = true
+license-file.workspace = true
+
+[dependencies]
+serde = { workspace = true }
+serde-wasm-bindgen = "0.6.5"
+wasm-bindgen = "0.2.93"
+web5 = { path = "../../crates/web5" }
+
+[lib]
+crate-type = ["cdylib"]

bindings/web5_wasm/src/crypto/dsa.rs

@@ -0,0 +1,63 @@
+use super::jwk::WasmJwk;
+use crate::errors::{map_err, Result};
+use std::sync::Arc;
+use wasm_bindgen::prelude::wasm_bindgen;
+use web5::crypto::dsa::{
+    ed25519::{Ed25519Generator, Ed25519Signer},
+    secp256k1::{Secp256k1Generator, Secp256k1Signer},
+    Signer,
+};
+
+#[wasm_bindgen]
+pub struct WasmSigner {
+    inner: Arc<dyn Signer>,
+}
+
+impl From<Ed25519Signer> for WasmSigner {
+    fn from(value: Ed25519Signer) -> Self {
+        Self {
+            inner: Arc::new(value),
+        }
+    }
+}
+
+impl From<Secp256k1Signer> for WasmSigner {
+    fn from(value: Secp256k1Signer) -> Self {
+        Self {
+            inner: Arc::new(value),
+        }
+    }
+}
+
+impl From<Arc<dyn Signer>> for WasmSigner {
+    fn from(value: Arc<dyn Signer>) -> Self {
+        Self { inner: value }
+    }
+}
+
+#[wasm_bindgen]
+impl WasmSigner {
+    pub fn sign(&self, payload: &[u8]) -> Result<Vec<u8>> {
+        self.inner.sign(payload).map_err(map_err)
+    }
+}
+
+#[wasm_bindgen]
+pub fn generate_ed25519_key() -> Result<WasmJwk> {
+    Ok(Ed25519Generator::generate().into())
+}
+
+#[wasm_bindgen]
+pub fn generate_secp256k1_key() -> Result<WasmJwk> {
+    Ok(Secp256k1Generator::generate().into())
+}
+
+#[wasm_bindgen]
+pub fn new_ed25519_signer(jwk: WasmJwk) -> Result<WasmSigner> {
+    Ok(Ed25519Signer::new(jwk.into()).into())
+}
+
+#[wasm_bindgen]
+pub fn new_secp256k1_signer(jwk: WasmJwk) -> Result<WasmSigner> {
+    Ok(Secp256k1Signer::new(jwk.into()).into())
+}

bindings/web5_wasm/src/crypto/jwk.rs

@@ -0,0 +1,79 @@
+use crate::errors::{map_err, Result};
+use wasm_bindgen::prelude::wasm_bindgen;
+use web5::crypto::jwk::Jwk;
+
+#[wasm_bindgen]
+pub struct WasmJwk {
+    inner: Jwk,
+}
+
+impl From<Jwk> for WasmJwk {
+    fn from(value: Jwk) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl From<WasmJwk> for Jwk {
+    fn from(value: WasmJwk) -> Self {
+        value.inner
+    }
+}
+
+#[wasm_bindgen]
+impl WasmJwk {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        alg: Option<String>,
+        kty: String,
+        crv: String,
+        d: Option<String>,
+        x: String,
+        y: Option<String>,
+    ) -> WasmJwk {
+        WasmJwk {
+            inner: Jwk {
+                alg,
+                kty,
+                crv,
+                d,
+                x,
+                y,
+            },
+        }
+    }
+
+    #[wasm_bindgen]
+    pub fn compute_thumbprint(&self) -> Result<String> {
+        self.inner.compute_thumbprint().map_err(map_err)
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn alg(&self) -> Option<String> {
+        self.inner.alg.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn kty(&self) -> String {
+        self.inner.kty.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn crv(&self) -> String {
+        self.inner.crv.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn d(&self) -> Option<String> {
+        self.inner.d.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn x(&self) -> String {
+        self.inner.x.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn y(&self) -> Option<String> {
+        self.inner.y.clone()
+    }
+}

bindings/web5_wasm/src/crypto/key_managers.rs

@@ -0,0 +1,75 @@
+use super::{dsa::WasmSigner, jwk::WasmJwk};
+use crate::errors::{map_err, Result};
+use std::sync::Arc;
+use wasm_bindgen::prelude::wasm_bindgen;
+use web5::crypto::{
+    jwk::Jwk,
+    key_managers::{in_memory_key_manager::InMemoryKeyManager, KeyManager},
+};
+
+#[wasm_bindgen]
+pub struct WasmKeyManager {
+    inner: Arc<dyn KeyManager>,
+}
+
+impl From<InMemoryKeyManager> for WasmKeyManager {
+    fn from(value: InMemoryKeyManager) -> Self {
+        Self {
+            inner: Arc::new(value),
+        }
+    }
+}
+
+#[wasm_bindgen]
+impl WasmKeyManager {
+    pub fn import_private_jwk(&self, private_jwk: WasmJwk) -> Result<WasmJwk> {
+        Ok(self
+            .inner
+            .import_private_jwk(private_jwk.into())
+            .map_err(map_err)?
+            .into())
+    }
+
+    pub fn get_signer(&self, public_jwk: WasmJwk) -> Result<WasmSigner> {
+        Ok(self
+            .inner
+            .get_signer(public_jwk.into())
+            .map_err(map_err)?
+            .into())
+    }
+}
+
+#[wasm_bindgen]
+pub fn new_in_memory_key_manager() -> Result<WasmKeyManager> {
+    Ok(InMemoryKeyManager::new().into())
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(
+        typescript_type = "{ importPrivateJwk: (privateJwk: WasmJwk) => WasmJwk, getSigner: (publicJwk: WasmJwk) => WasmSigner }"
+    )]
+    pub type ForeignKeyManager;
+
+    #[wasm_bindgen(method)]
+    fn import_private_jwk(this: &ForeignKeyManager, private_jwk: WasmJwk) -> WasmJwk;
+
+    #[wasm_bindgen(method)]
+    fn get_signer(this: &ForeignKeyManager, public_jwk: WasmJwk) -> WasmSigner;
+}
+
+#[wasm_bindgen]
+pub fn poc_key_manager_from_foreign(key_manager: &ForeignKeyManager) -> WasmSigner {
+    let private_jwk = Jwk {
+        alg: Some("Ed25519".to_string()),
+        kty: "OKP".to_string(),
+        crv: "Ed25519".to_string(),
+        d: Some("UMxzGsW84I6kS3JkenqYI1gH0GmvxYG2ovI69Vlno8g".to_string()),
+        x: "EzbXpICojY4ZI2i775GwkkTIbe5nuLL13JbdzUfsO6Q".to_string(),
+        y: None,
+    };
+
+    let public_jwk = key_manager.import_private_jwk(private_jwk.into());
+    let signer = key_manager.get_signer(public_jwk);
+    signer
+}

bindings/web5_wasm/src/crypto/mod.rs

@@ -0,0 +1,3 @@
+pub mod dsa;
+pub mod jwk;
+pub mod key_managers;

bindings/web5_wasm/src/errors.rs

@@ -0,0 +1,45 @@
+use serde::Serialize;
+use serde_wasm_bindgen::to_value;
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+use web5::errors::Web5Error;
+
+pub type Result<T> = std::result::Result<T, JsValue>;
+
+#[wasm_bindgen]
+#[derive(Serialize)]
+pub struct WasmWeb5Error {
+    variant: String,
+    message: String,
+    is_web5_error: bool,
+}
+
+#[wasm_bindgen]
+impl WasmWeb5Error {
+    #[wasm_bindgen(getter)]
+    pub fn variant(&self) -> String {
+        self.variant.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn is_web5_error(&self) -> bool {
+        self.is_web5_error.clone()
+    }
+}
+
+pub fn map_err(err: Web5Error) -> JsValue {
+    let msg = format!("{:?}", err);
+    let variant = msg.split('(').next().unwrap_or("Unknown").to_string();
+
+    let js_error = WasmWeb5Error {
+        variant,
+        message: err.to_string(),
+        is_web5_error: true,
+    };
+
+    to_value(&js_error).unwrap_or_else(|_| JsValue::from_str("failed to serialize error"))
+}

bindings/web5_wasm/src/lib.rs

@@ -0,0 +1,36 @@
+pub mod crypto;
+
+pub mod errors;
+
+use wasm_bindgen::prelude::*;
+
+// #[wasm_bindgen]
+// extern "C" {
+//     pub type JsFunction;
+
+//     #[wasm_bindgen(method)]
+//     fn call(this: &JsFunction);
+// }
+
+// #[wasm_bindgen]
+// pub fn call_js_function(f: &JsFunction) {
+//     f.call();
+// }
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "{hello1: Function, hello2: Function}")]
+    pub type JsObject1;
+
+    #[wasm_bindgen(method)]
+    fn hello1(this: &JsObject1);
+
+    #[wasm_bindgen(method)]
+    fn hello2(this: &JsObject1);
+}
+
+#[wasm_bindgen]
+pub fn call_js_functions(obj: &JsObject1) {
+    obj.hello1();
+    obj.hello2();
+}