feat: add noirc_abi_wasm crate for ABI encoding in JS

Cargo.toml

@@ -10,6 +10,7 @@ members = [
     "crates/fm",
     "crates/arena",
     "crates/noirc_abi",
+    "crates/noirc_abi_wasm",
     "crates/iter-extended",
     "crates/wasm",
 ]

crates/noirc_abi_wasm/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "noirc_abi_wasm"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+acvm.workspace = true
+noirc_abi.workspace = true
+iter-extended.workspace = true
+wasm-bindgen.workspace = true
+serde.workspace = true
+
+js-sys = "0.3.62"
+log = "0.4.17"
+wasm-logger = "0.2.0"
+console_error_panic_hook = "0.1.7"
+gloo-utils = { version = "0.1", features = ["serde"] }
+
+# This is an unused dependency, we are adding it
+# so that we can enable the js feature in getrandom.
+getrandom = { version = "*", features = ["js"] }
+
+[build-dependencies]
+build-data = "0.1.3"
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3.36"

crates/noirc_abi_wasm/README.md

@@ -0,0 +1,17 @@
+# Noir Lang ABi JavaScript Package
+
+This JavaScript package enables users to ABI encode inputs to a Noir program, i.e. generating an initial witness.
+
+## Building from source
+
+Outside of the [noir repo](https://github.com/noir-lang/noir), this package can be built using the command below:
+
+```bash
+nix build -L github:noir-lang/noir/master#abi_wasm
+```
+
+If you are within the noir repo and would like to build local changes, you can use:
+
+```bash
+nix build -L #abi_wasm
+```

crates/noirc_abi_wasm/build.rs

@@ -0,0 +1,14 @@
+const GIT_COMMIT: &&str = &"GIT_COMMIT";
+
+fn main() {
+    // Only use build_data if the environment variable isn't set
+    // The environment variable is always set when working via Nix
+    if std::env::var(GIT_COMMIT).is_err() {
+        build_data::set_GIT_COMMIT();
+        build_data::set_GIT_DIRTY();
+        build_data::no_debug_rebuilds();
+    }
+
+    build_data::set_SOURCE_TIMESTAMP();
+    build_data::no_debug_rebuilds();
+}

crates/noirc_abi_wasm/build.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+function require_command {
+    if ! command -v "$1" >/dev/null 2>&1; then
+        echo "Error: $1 is required but not installed." >&2
+        exit 1
+    fi
+}
+
+require_command toml2json
+require_command jq
+require_command cargo
+require_command wasm-bindgen
+require_command wasm-opt
+
+export pname=$(toml2json < Cargo.toml | jq -r .package.name)
+
+./preBuild.sh
+cargo build --lib --release --package noirc_abi_wasm --target wasm32-unknown-unknown
+./postBuild.sh
+./installPhase.sh
+

crates/noirc_abi_wasm/installPhase.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+mkdir -p $out
+cp ./crates/wasm/README.md $out/
+cp ./crates/wasm/package.json $out/
+cp -r ./pkg/* $out/
+
+echo "## Tracking" >> $out/README.md
+echo "Built from [noir-lang/noir@$GIT_COMMIT](https://github.com/noir-lang/noir/tree/$GIT_COMMIT)" >> $out/README.md

crates/noirc_abi_wasm/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@noir-lang/noir_wasm",
+  "collaborators": [
+    "The Noir Team <team@noir-lang.org>"
+  ],
+  "version": "0.8.0",
+  "files": [
+    "nodejs",
+    "web",
+    "package.json"
+  ],
+  "main": "./nodejs/noir_wasm.js",
+  "types": "./web/noir_wasm.d.ts",
+  "module": "./web/noir_wasm.js",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@noir-lang/noir-source-resolver": "1.1.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/noir-lang/noir_wasm.git"
+  }
+}

crates/noirc_abi_wasm/postBuild.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+# TODO: Handle the wasm target being built in release mode
+WASM_BINARY=./target/wasm32-unknown-unknown/release/${pname}.wasm
+NODE_WASM=./pkg/nodejs/${pname}_bg.wasm
+BROWSER_WASM=./pkg/web/${pname}_bg.wasm
+
+wasm-bindgen $WASM_BINARY --out-dir ./pkg/nodejs --typescript --target nodejs
+wasm-bindgen $WASM_BINARY --out-dir ./pkg/web --typescript --target web
+wasm-opt $NODE_WASM -o $NODE_WASM -O
+wasm-opt $BROWSER_WASM -o $BROWSER_WASM -O

crates/noirc_abi_wasm/preBuild.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+# Clear out the existing build artifacts as these aren't automatically removed by wasm-pack.
+if [ -d ./pkg/ ]; then
+    rm -rf ./pkg/
+fi

crates/noirc_abi_wasm/src/js_witness_map.rs

@@ -0,0 +1,112 @@
+use acvm::{
+    acir::native_types::{Witness, WitnessMap},
+    FieldElement,
+};
+use js_sys::{JsString, Map};
+use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
+
+#[wasm_bindgen(typescript_custom_section)]
+const WITNESS_MAP: &'static str = r#"
+// Map from witness index to hex string value of witness.
+export type WitnessMap = Map<number, string>;
+"#;
+
+// WitnessMap
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Map, js_name = "WitnessMap", typescript_type = "WitnessMap")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JsWitnessMap;
+
+    #[wasm_bindgen(constructor, js_class = "Map")]
+    pub fn new() -> JsWitnessMap;
+
+}
+
+impl Default for JsWitnessMap {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl From<WitnessMap> for JsWitnessMap {
+    fn from(witness_map: WitnessMap) -> Self {
+        let js_map = JsWitnessMap::new();
+        for (key, value) in witness_map {
+            js_map.set(
+                &js_sys::Number::from(key.witness_index()),
+                &field_element_to_js_string(&value),
+            );
+        }
+        js_map
+    }
+}
+
+impl From<JsWitnessMap> for WitnessMap {
+    fn from(js_map: JsWitnessMap) -> Self {
+        let mut witness_map = WitnessMap::new();
+        js_map.for_each(&mut |value, key| {
+            let witness_index = Witness(key.as_f64().unwrap() as u32);
+            let witness_value = js_value_to_field_element(value).unwrap();
+            witness_map.insert(witness_index, witness_value);
+        });
+        witness_map
+    }
+}
+
+pub(crate) fn js_value_to_field_element(js_value: JsValue) -> Result<FieldElement, JsString> {
+    let hex_str = js_value.as_string().ok_or("failed to parse field element from non-string")?;
+
+    FieldElement::from_hex(&hex_str)
+        .ok_or_else(|| format!("Invalid hex string: '{}'", hex_str).into())
+}
+
+pub(crate) fn field_element_to_js_string(field_element: &FieldElement) -> JsString {
+    // This currently maps `0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000`
+    // to the bigint `-1n`. This fails when converting back to a `FieldElement`.
+    // js_sys::BigInt::from_str(&value.to_hex()).unwrap()
+
+    format!("0x{}", field_element.to_hex()).into()
+}
+
+#[cfg(test)]
+mod test {
+    use wasm_bindgen_test::wasm_bindgen_test as test;
+
+    use std::collections::BTreeMap;
+
+    use acvm::{
+        acir::native_types::{Witness, WitnessMap},
+        FieldElement,
+    };
+    use wasm_bindgen::JsValue;
+
+    use crate::JsWitnessMap;
+
+    #[test]
+    fn test_witness_map_to_js() {
+        let witness_map = BTreeMap::from([
+            (Witness(1), FieldElement::one()),
+            (Witness(2), FieldElement::zero()),
+            (Witness(3), -FieldElement::one()),
+        ]);
+        let witness_map = WitnessMap::from(witness_map);
+
+        let js_map = JsWitnessMap::from(witness_map);
+
+        assert_eq!(
+            js_map.get(&JsValue::from(1)),
+            JsValue::from_str("0x0000000000000000000000000000000000000000000000000000000000000001")
+        );
+        assert_eq!(
+            js_map.get(&JsValue::from(2)),
+            JsValue::from_str("0x0000000000000000000000000000000000000000000000000000000000000000")
+        );
+        assert_eq!(
+            js_map.get(&JsValue::from(3)),
+            // Equal to 21888242871839275222246405745257275088548364400416034343698204186575808495616,
+            // which is field modulus - 1: https://docs.rs/ark-bn254/latest/ark_bn254/
+            JsValue::from_str("0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000")
+        );
+    }
+}