Merge pull request #3835 from dusk-network/ffi-datadriver

data-driver: add standard wasm implementation

Author: miloszm

Cargo.lock

@@ -163,7 +163,6 @@ tracing-subscriber = "0.3.18"
 tungstenite = "0.21"
 url = "2.5.2"
 version_check = "0.9.5"
-wasm-bindgen = "0.2"
 zeroize = { version = "1.8.1", default-features = false }
 zip = "0.5.13"
 

Cargo.toml

@@ -21,6 +21,9 @@ wasm: setup-compiler ## Generate the WASM for all the contracts and wallet-core
 data-drivers: ## Build the data-driver WASM files
 	$(MAKE) -C ./data-drivers wasm
 
+data-drivers-js: ## Build the data-driver WASM files (with alloc support for JS)
+	$(MAKE) -C ./data-drivers wasm-js
+
 contracts: setup-compiler ## Execute the test for all contracts
 	$(MAKE) -j1 -C ./contracts all
 

Makefile

@@ -9,6 +9,8 @@ help: ## Display this help screen
 
 test: $(SUBDIRS) ## Run all the tests in the subfolder
 
+wasm-js: $(SUBDIRS) ## Build the data-driver WASM files (with alloc support for JS)
+
 wasm: $(SUBDIRS) ## Build the data-driver WASM files
 
 clippy: $(SUBDIRS) ## Run clippy

data-drivers/Makefile

@@ -14,3 +14,7 @@ bytecheck = { workspace = true }
 # serde support dependencies
 serde = { workspace = true }
 serde_json = { workspace = true }
+
+[features]
+wasm-export = []
+alloc = []

data-drivers/data-driver/Cargo.toml

@@ -8,12 +8,16 @@ help: ## Display this help screen
 
 wasm: ## Noop
 
+wasm-js: ## Noop
+
 test: ## Perform the contract tests defined in the host module
 	@cargo test --release
 
 clippy: ## Run clippy
 	@cargo clippy --release -- -D warnings
 	@cargo clippy --release --target wasm32-unknown-unknown -- -D warnings
+	@cargo clippy --release --target wasm32-unknown-unknown --features wasm-export -- -D warnings
+	@cargo clippy --release --target wasm32-unknown-unknown --features wasm-export,alloc -- -D warnings
 
 doc: ## Run doc gen
 	@cargo doc --release

data-drivers/data-driver/Makefile

@@ -0,0 +1,149 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+export async function loadDriverWasm(bytes) {
+    const wasmModule = await WebAssembly.instantiate(bytes, { env: {} });
+    const exports = wasmModule.instance.exports;
+    const memory = exports.memory;
+
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+
+    // -- Helpers --
+    function allocAndWriteString(str) {
+        const bytes = textEncoder.encode(str);
+        const ptr = exports.alloc(bytes.length);
+        new Uint8Array(memory.buffer, ptr, bytes.length).set(bytes);
+        return [ptr, bytes.length];
+    }
+
+    function allocAndWriteBytes(bytes) {
+        const ptr = exports.alloc(bytes.length);
+        new Uint8Array(memory.buffer, ptr, bytes.length).set(bytes);
+        return [ptr, bytes.length];
+    }
+
+    function readBuffer(ptr, bufSize) {
+        const view = new DataView(memory.buffer, ptr, 4);
+        const actualSize = view.getUint32(0, true);
+
+        if (actualSize > bufSize - 4) {
+            exports.dealloc(ptr, bufSize);
+            throw new Error(`Invalid output size: ${actualSize}`);
+        }
+
+        const data = new Uint8Array(memory.buffer, ptr + 4, actualSize);
+        const result = data.slice(); // clone to detach from WASM memory
+        return result;
+    }
+
+    function runWithOutputBuffer(fn) {
+        const outSize = 64 * 1024; // 64 KB default buffer
+        const outPtr = exports.alloc(outSize);
+        try {
+            const code = fn(outPtr, outSize);
+            if (code !== 0) {
+                const errMsg = _internalGetLastError();
+                throw new Error(`FFI call failed (${code}): ${errMsg}`);
+            }
+            return readBuffer(outPtr, outSize);
+        } finally {
+            exports.dealloc(outPtr, outSize);
+        }
+    }
+
+    function _internalGetLastError() {
+        const outSize = 1024;
+        const outPtr = exports.alloc(outSize);
+        try {
+            exports.get_last_error(outPtr, outSize);
+            const result = readBuffer(outPtr, outSize);
+            return textDecoder.decode(result);
+        } finally {
+            exports.dealloc(outPtr, outSize);
+        }
+    }
+
+    return {
+        /** Initializes the contract driver */
+        init: () => exports.init(),
+
+        /** Encodes JSON input into RKYV bytes */
+        encodeInputFn: (fnName, json) => {
+            const [fnPtr, fnLen] = allocAndWriteString(fnName);
+            const [jsonPtr, jsonLen] = allocAndWriteString(json);
+
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.encode_input_fn(fnPtr, fnLen, jsonPtr, jsonLen, outPtr, outSize)
+            );
+
+            exports.dealloc(fnPtr, fnLen);
+            exports.dealloc(jsonPtr, jsonLen);
+
+            return result; // returns Uint8Array
+        },
+
+        /** Decodes RKYV input bytes into JSON */
+        decodeInputFn: (fnName, rkyvBytes) => {
+            const [fnPtr, fnLen] = allocAndWriteString(fnName);
+            const [rkyvPtr, rkyvLen] = allocAndWriteBytes(rkyvBytes);
+
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.decode_input_fn(fnPtr, fnLen, rkyvPtr, rkyvLen, outPtr, outSize)
+            );
+
+            exports.dealloc(fnPtr, fnLen);
+            exports.dealloc(rkyvPtr, rkyvLen);
+
+            return JSON.parse(textDecoder.decode(result));
+        },
+
+        /** Decodes RKYV output bytes into JSON */
+        decodeOutputFn: (fnName, rkyvBytes) => {
+            const [fnPtr, fnLen] = allocAndWriteString(fnName);
+            const [rkyvPtr, rkyvLen] = allocAndWriteBytes(rkyvBytes);
+
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.decode_output_fn(fnPtr, fnLen, rkyvPtr, rkyvLen, outPtr, outSize)
+            );
+
+            exports.dealloc(fnPtr, fnLen);
+            exports.dealloc(rkyvPtr, rkyvLen);
+
+            return JSON.parse(textDecoder.decode(result));
+        },
+
+        /** Decodes RKYV event bytes into JSON */
+        decodeEvent: (eventName, rkyvBytes) => {
+            const [eventPtr, eventLen] = allocAndWriteString(eventName);
+            const [rkyvPtr, rkyvLen] = allocAndWriteBytes(rkyvBytes);
+
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.decode_event(eventPtr, eventLen, rkyvPtr, rkyvLen, outPtr, outSize)
+            );
+
+            exports.dealloc(eventPtr, eventLen);
+            exports.dealloc(rkyvPtr, rkyvLen);
+
+            return JSON.parse(textDecoder.decode(result));
+        },
+
+        /** Returns the contract's JSON schema */
+        getSchema: () => {
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.get_schema(outPtr, outSize)
+            );
+            return JSON.parse(textDecoder.decode(result));
+        },
+
+        /** Returns the contract's JSON schema */
+        getVersion: () => {
+            const result = runWithOutputBuffer((outPtr, outSize) =>
+                exports.get_version(outPtr, outSize)
+            );
+            return textDecoder.decode(result);
+        },
+    };
+}

data-drivers/data-driver/loader.mjs

@@ -18,6 +18,12 @@ extern crate alloc;
 
 mod error;
 
+#[cfg(all(target_family = "wasm", feature = "wasm-export"))]
+pub mod wasm;
+
+#[cfg(all(target_family = "wasm", feature = "alloc"))]
+mod mem;
+
 use alloc::string::ToString;
 use alloc::vec;
 use alloc::vec::Vec;

data-drivers/data-driver/src/lib.rs

@@ -0,0 +1,28 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+use alloc::vec::Vec;
+
+/// Allocate memory inside WASM for JS to write into.
+/// Returns a pointer to a buffer of size `size`.
+#[no_mangle]
+pub extern "C" fn alloc(size: usize) -> *mut u8 {
+    let mut buf = Vec::with_capacity(size);
+    let ptr = buf.as_mut_ptr();
+    core::mem::forget(buf);
+    ptr
+}
+
+/// Deallocate memory previously allocated with `alloc`.
+///
+/// # Safety
+/// The pointer must have been returned by `alloc` with the same `size`.
+/// The memory must not have been previously deallocated.
+/// After calling this function, the pointer must no longer be used.
+#[no_mangle]
+pub unsafe extern "C" fn dealloc(ptr: *mut u8, size: usize) {
+    drop(Vec::from_raw_parts(ptr, size, size));
+}