@dashevo/wasm-dpp 0.23.0-dev.14 → 0.24.0-dev.10

package/index.ts

@@ -0,0 +1,30 @@
+import init, * as dpp_module from './wasm/wasm_dpp';
+// @ts-ignore
+import wasmBase from './wasm/wasm_dpp_bg.js';
+import patchIdentifier from "./lib/patchIdentifier";
+
+let isInitialized = false;
+
+export default async function loadDpp() {
+  if (isInitialized) {
+    return dpp_module;
+  } else {
+    // @ts-ignore
+    let bytes = Buffer.from(wasmBase, 'base64');
+
+    if (typeof fetch !== 'undefined') {
+      let blob = new Blob([bytes], { type: "application/wasm" });
+      let wasmUrl = URL.createObjectURL(blob);
+      await init(wasmUrl);
+      isInitialized = true;
+    }  else {
+      dpp_module.initSync(bytes);
+      isInitialized = true;
+    }
+
+    patchIdentifier(dpp_module);
+
+    return dpp_module;
+  }
+};
+

package/karma.conf.js

@@ -24,15 +24,18 @@ module.exports = (config) => {
         minimize: false,
         moduleIds: 'named',
       },
-      plugins: webpackConfig[0].plugins,
-      resolve: webpackConfig[0].resolve,
+      plugins: webpackConfig.plugins,
+      resolve: webpackConfig.resolve,
     },
     reporters: ['mocha'],
     port: 9876,
     colors: true,
     logLevel: config.LOG_INFO,
     autoWatch: false,
-    browsers: ['ChromeHeadless', 'FirefoxHeadless'],
+    browsers: [
+      'ChromeHeadless',
+      'FirefoxHeadless',
+    ],
     singleRun: false,
     concurrency: Infinity,
     plugins: [

package/lib/patchIdentifier.ts

@@ -0,0 +1,37 @@
+import * as dpp_module from "../wasm/wasm_dpp";
+// import { inspect } from 'util';
+
+export default function (dppModule: typeof dpp_module) {
+    // As Identifier is now exported from WASM, it can no longer
+    // patched the same way as JS implementation did. This module
+    // adds everything that's currently missing from Identifier that can't
+    // be implemented in Rust directly.
+    const { Identifier } = dppModule;
+
+    //@ts-ignore
+    Object.setPrototypeOf(Identifier.prototype, Buffer.prototype);
+
+    Identifier.prototype.valueOf = function() {
+        return Buffer.from(this.inner());
+    }
+
+    // @ts-ignore
+    Identifier.prototype.encodeCBOR = function encodeCBOR(encoder) {
+        // @ts-ignore
+        encoder.pushAny(this.valueOf());
+
+        return true;
+    };
+
+    // @ts-ignore
+    Identifier.prototype.inspect = function(...args) {
+        return this.valueOf().inspect(...args);
+    }
+
+    // TODO: THIS MAKES BUFFERS PRINTABLE IN NODE.JS, BUT FOR THIS TO WORK
+    //  target: node has to be specified and utils have to be included __without__ using
+    //  polyfills. This in turn will make web version not work. The code is as follows:
+    //  console.log("custom:", inspect.custom);
+    //  //@ts-ignore
+    //  Identifier.prototype[inspect.custom] = Identifier.prototype.inspect;
+}

package/lib/test/.eslintrc

@@ -0,0 +1,9 @@
+{
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "rules": {
+    "import/no-extraneous-dependencies": "off"
+  }
+}

package/lib/test/bootstrap.js

@@ -0,0 +1,27 @@
+const { expect, use } = require('chai');
+const sinon = require('sinon');
+const sinonChai = require('sinon-chai');
+const dirtyChai = require('dirty-chai');
+const chaiAsPromised = require('chai-as-promised');
+const chaiString = require('chai-string');
+const chaiExclude = require('chai-exclude');
+
+use(sinonChai);
+use(chaiAsPromised);
+use(dirtyChai);
+use(chaiString);
+use(chaiExclude);
+
+beforeEach(function beforeEach() {
+  if (!this.sinonSandbox) {
+    this.sinonSandbox = sinon.createSandbox();
+  } else {
+    this.sinonSandbox.restore();
+  }
+});
+
+afterEach(function afterEach() {
+  this.sinonSandbox.restore();
+});
+
+global.expect = expect;

package/lib/test/expect/expectError.js

@@ -0,0 +1,34 @@
+const { expect } = require('chai');
+
+const { default: loadWasmDpp } = require('../../../dist');
+
+const expectError = {
+  /**
+   * @param {ValidationResult} result
+   * @param {AbstractConsensusError} [errorClass]
+   * @param {number} [count]
+   */
+  async expectValidationError(result, errorClass, count = 1) {
+    const wasmDpp = await loadWasmDpp();
+    if (!errorClass) {
+      // eslint-disable-next-line no-param-reassign
+      errorClass = wasmDpp.ValidationResult;
+    }
+    expect(result).to.be.an.instanceOf(wasmDpp.ValidationResult);
+    expect(result.getErrors()).to.have.lengthOf(count);
+
+    result.getErrors().forEach((error) => expect(error).to.be.an.instanceOf(errorClass));
+  },
+
+  /**
+   *
+   * @param {ValidationResult} result
+   * @param [count]
+   */
+  async expectJsonSchemaError(result, count = 1) {
+    const wasmDpp = await loadWasmDpp();
+    await expectError.expectValidationError(result, wasmDpp.JsonSchemaError, count);
+  },
+};
+
+module.exports = expectError;

package/lib/test/karma/loader.js

@@ -0,0 +1,6 @@
+// This file is used for compiling tests with webpack into one file for using with karma
+require('../bootstrap');
+
+const testsContext = require.context('../../../test', true, /\.spec\.js$/);
+
+testsContext.keys().forEach(testsContext);

package/lib/test/utils/generateRandomIdentifierAsync.js

@@ -0,0 +1,14 @@
+const crypto = require('crypto');
+const { default: loadWasmDpp } = require('../../../dist');
+
+/**
+ * Generate random identity ID
+ *
+ * @return {Identifier}
+ */
+async function generateRandomIdentifierAsync() {
+  const { Identifier } = await loadWasmDpp();
+  return new Identifier(crypto.randomBytes(32));
+}
+
+module.exports = generateRandomIdentifierAsync;

package/package.json

@@ -1,64 +1,61 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.23.0-dev.14",
+  "version": "0.24.0-dev.10",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "lint": "eslint .",
-    "test": "yarn run test:coverage && yarn run test:browsers",
-    "build:web": "webpack --stats-error-details",
-    "test:node": "NODE_ENV=test mocha",
+    "build": "yarn exec scripts/build.sh && webpack",
+    "test": "yarn run test:node && yarn run test:browsers",
     "test:browsers": "karma start ./karma.conf.js --single-run",
-    "test:coverage": "NODE_ENV=test nyc --check-coverage --stmts=98 --branch=94 --funcs=95 --lines=97 yarn run mocha 'test/unit/**/*.spec.js' 'test/integration/**/*.spec.js'",
-    "prepublishOnly": "yarn run build:web"
+    "test:node": "NODE_ENV=test mocha",
+    "webpack": "webpack",
+    "lint": "eslint . && cargo clippy && cargo fmt --check",
+    "lint:fix": "eslint . --fix && cargo clippy --fix && cargo fmt",
+    "clean": "yarn exec scripts/clean.sh"
   },
   "ultra": {
     "concurrent": [
-      "test"
+      "test",
+      "lint"
     ]
   },
-  "main": "lib/index.js",
+  "author": "Dash Core Team",
   "contributors": [
     {
       "name": "Anton Suprunchuk",
-      "email": "anton.suprunchuk@dash.org",
+      "email": "anton.suprunchuk@gmail.com",
       "url": "https://github.com/antouhou"
-    },
-    {
-      "name": "Ivan Shumkov",
-      "email": "ivan@shumkov.ru",
-      "url": "https://github.com/shumkov"
-    },
-    {
-      "name": "Djavid Gabibiyan",
-      "email": "djavid@dash.org",
-      "url": "https://github.com/jawid-h"
-    },
-    {
-      "name": "Konstantin Shuplenkov",
-      "email": "konstantin.shuplenkov@dash.org",
-      "url": "https://github.com/shuplenkov"
     }
   ],
   "license": "MIT",
+  "dependencies": {
+    "@dashevo/bls": "~1.0.0-beta.2"
+  },
   "devDependencies": {
-    "@babel/core": "^7.15.5",
-    "@babel/preset-env": "^7.15.4",
-    "acorn": "^8.5.0",
+    "@apidevtools/json-schema-ref-parser": "^8.0.0",
+    "@dashevo/dashcore-lib": "~0.19.44",
+    "@dashevo/dpns-contract": "0.24.0-dev.10",
+    "@dashevo/dpp": "0.24.0-dev.10",
+    "@dashevo/wasm-re2": "~1.0.2",
+    "@types/node": "^14.6.0",
+    "ajv": "^8.6.0",
     "assert": "^2.0.0",
-    "babel-loader": "^8.2.2",
+    "bs58": "^4.0.1",
     "buffer": "^6.0.3",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "chai-exclude": "^2.1.0",
     "chai-string": "^1.5.0",
-    "core-js": "^3.17.2",
     "crypto-browserify": "^3.12.0",
     "dirty-chai": "^2.0.1",
     "eslint": "^7.32.0",
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.24.2",
     "events": "^3.3.0",
+    "fast-json-patch": "^3.1.0",
     "https-browserify": "^1.0.0",
+    "json-schema-diff-validator": "^0.4.1",
     "karma": "^6.4.1",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
@@ -66,9 +63,9 @@
     "karma-mocha": "^2.0.1",
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^5.0.0",
+    "lodash": "^4.17.21",
+    "long": "^5.2.0",
     "mocha": "^9.1.2",
-    "node-inspect-extracted": "^1.0.8",
-    "nyc": "^15.1.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
     "sinon": "^11.1.2",
@@ -76,32 +73,11 @@
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "string_decoder": "^1.3.0",
+    "ts-loader": "^8.0.2",
+    "typescript": "^3.9.5",
     "url": "^0.11.0",
     "util": "^0.12.4",
     "webpack": "^5.59.1",
     "webpack-cli": "^4.9.1"
-  },
-  "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "^8.0.0",
-    "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dashpay-contract": "0.24.0-dev.5",
-    "@dashevo/dpns-contract": "0.24.0-dev.5",
-    "@dashevo/feature-flags-contract": "0.24.0-dev.5",
-    "@dashevo/masternode-reward-shares-contract": "0.24.0-dev.5",
-    "@dashevo/wasm-re2": "~1.0.2",
-    "ajv": "^8.6.0",
-    "ajv-formats": "^2.1.1",
-    "bignumber.js": "^9.0.1",
-    "bls-signatures": "^0.2.5",
-    "bs58": "^4.0.1",
-    "cbor": "^8.0.0",
-    "fast-json-patch": "^3.1.0",
-    "json-schema-diff-validator": "^0.4.1",
-    "json-schema-traverse": "^1.0.0",
-    "lodash.clonedeep": "^4.5.0",
-    "lodash.clonedeepwith": "^4.5.0",
-    "lodash.get": "^4.4.2",
-    "lodash.set": "^4.3.2",
-    "long": "^5.2.0"
   }
 }

package/scripts/build.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+
+TARGET=wasm32-unknown-unknown
+
+PROFILE_ARG=""
+PROFILE="debug"
+
+if [ -n "$CARGO_BUILD_PROFILE" ]; then
+    if [ "$CARGO_BUILD_PROFILE" == "release" ]; then
+      PROFILE_ARG="--release"
+      PROFILE="release"
+    elif [ "$CARGO_BUILD_PROFILE" != "debug" ]; then
+      PROFILE_ARG="--profile $CARGO_BUILD_PROFILE"
+      PROFILE="$CARGO_BUILD_PROFILE"
+    fi
+fi
+
+OUTPUT_DIR="$PWD/wasm"
+OUTPUT_FILE="$OUTPUT_DIR/wasm_dpp_bg.wasm"
+OUTPUT_FILE_JS="$OUTPUT_DIR/wasm_dpp_bg.js"
+BUILD_COMMAND="cargo build --target=$TARGET $PROFILE_ARG"
+BINDGEN_COMMAND="wasm-bindgen --out-dir=$OUTPUT_DIR --target=web --omit-default-module-path ../../target/$TARGET/$PROFILE/wasm_dpp.wasm"
+
+DIST_TYPINGS="$PWD/dist/wasm/wasm_dpp.d.ts"
+WASM_TYPINGS_PATH="$OUTPUT_DIR/wasm_dpp.d.ts"
+
+
+if ! [[ -d $OUTPUT_DIR ]];  then
+  mkdir -p "$OUTPUT_DIR"
+fi
+
+if ! [ -x "$(command -v wasm-bindgen)" ]; then
+    echo 'Wasm-bindgen CLI is not installed. Installing';
+    cargo install -f wasm-bindgen-cli
+fi
+
+
+# On a mac, bundled clang won't work - you need to install LLVM manually through brew,
+# and then set the correct env for the build to work
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    AR_PATH=$(which llvm-ar)
+    CLANG_PATH=$(which clang)
+    AR=$AR_PATH CC=$CLANG_PATH $BUILD_COMMAND
+    AR=$AR_PATH CC=$CLANG_PATH $BINDGEN_COMMAND
+else
+    $BUILD_COMMAND
+    $BINDGEN_COMMAND
+fi
+
+# EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0 --no-entry" cargo build --target=wasm32-unknown-emscripten --release
+# EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0 --no-entry" wasm-bindgen --out-dir=wasm --target=web --omit-default-module-path ../../target/wasm32-unknown-emscripten/release/wasm_dpp.wasm
+
+# TODO: Must be somehow preinstalled?
+#if [ "$PROFILE" == "release" ]; then
+#  echo "Optimizing wasm using Binaryen"
+#  wasm-opt -Os "$OUTPUT_FILE" -o "$OUTPUT_FILE"
+#fi
+
+# Converting wasm into base64 so it can be bundled
+echo "Converting wasm binary into base64 module for bundling with Webpack"
+WASM_BUILD_BASE_64=$(base64 -i "$OUTPUT_FILE")
+echo 'module.exports = "'${WASM_BUILD_BASE_64}'"' > "$OUTPUT_FILE_JS"
+
+mkdir "$PWD/dist/"
+
+echo "Copying wasm typings"
+mkdir "$PWD/dist/wasm"
+cp "$WASM_TYPINGS_PATH" "$DIST_TYPINGS"
+echo "Typings copied"

package/scripts/clean.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+rm -rf "$PWD"/dist
+rm -rf "$PWD"/wasm

package/src/bls_adapter.rs

@@ -0,0 +1,71 @@
+use dpp::dashcore::anyhow::anyhow;
+use dpp::{BlsModule, PublicKeyValidationError};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    pub type JsBlsAdapter;
+
+    #[wasm_bindgen(method)]
+    pub fn validatePublicKey(this: &JsBlsAdapter, pk: &[u8]) -> bool;
+
+    #[wasm_bindgen(method, catch)]
+    pub fn verifySignature(
+        this: &JsBlsAdapter,
+        signature: &[u8],
+        data: &[u8],
+        public_key: &[u8],
+    ) -> Result<bool, JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    pub fn privateKeyToPublicKey(
+        this: &JsBlsAdapter,
+        private_key: &[u8],
+    ) -> Result<js_sys::Uint8Array, JsValue>;
+
+    #[wasm_bindgen(method, catch)]
+    pub fn sign(
+        this: &JsBlsAdapter,
+        data: &[u8],
+        private_key: &[u8],
+    ) -> Result<js_sys::Uint8Array, JsValue>;
+}
+
+pub struct BlsAdapter(pub JsBlsAdapter);
+
+impl BlsModule for BlsAdapter {
+    fn validate_public_key(&self, pk: &[u8]) -> Result<(), PublicKeyValidationError> {
+        let is_valid = self.0.validatePublicKey(pk);
+
+        if !is_valid {
+            return Err(PublicKeyValidationError::new("Invalid public key"));
+        }
+
+        Ok(())
+    }
+
+    fn verify_signature(
+        &self,
+        signature: &[u8],
+        data: &[u8],
+        public_key: &[u8],
+    ) -> Result<bool, dpp::ProtocolError> {
+        self.0
+            .verifySignature(signature, data, public_key)
+            .map_err(|_v| anyhow!("Can't verify signature").into())
+    }
+
+    fn private_key_to_public_key(&self, private_key: &[u8]) -> Result<Vec<u8>, dpp::ProtocolError> {
+        self.0
+            .privateKeyToPublicKey(private_key)
+            .map(|arr| arr.to_vec())
+            .map_err(|_v| anyhow!("Can't convert private key to public key").into())
+    }
+
+    fn sign(&self, data: &[u8], private_key: &[u8]) -> Result<Vec<u8>, dpp::ProtocolError> {
+        self.0
+            .sign(data, private_key)
+            .map(|arr| arr.to_vec())
+            .map_err(|_v| anyhow!("Can't sign").into())
+    }
+}

package/src/buffer.rs

@@ -0,0 +1,15 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    pub type Buffer;
+
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Buffer;
+
+    #[wasm_bindgen(constructor, js_name = "from")]
+    pub fn from_bytes(js_sys: &[u8]) -> Buffer;
+
+    #[wasm_bindgen(constructor, js_name = "from")]
+    pub fn from_string(js_sys: String) -> Buffer;
+}

package/src/dash_platform_protocol.rs

@@ -0,0 +1,26 @@
+use std::sync::Arc;
+
+use wasm_bindgen::prelude::*;
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use dpp::identity::validation::PublicKeysValidator;
+use dpp::identity::IdentityFacade;
+use dpp::version::ProtocolVersionValidator;
+
+#[wasm_bindgen(js_name=DashPlatformProtocol)]
+pub struct DashPlatformProtocol(IdentityFacade<BlsAdapter>);
+
+#[wasm_bindgen(js_class=DashPlatformProtocol)]
+impl DashPlatformProtocol {
+    #[wasm_bindgen(constructor)]
+    pub fn new(bls_adapter: JsBlsAdapter) -> DashPlatformProtocol {
+        let bls = BlsAdapter(bls_adapter);
+        // TODO: remove default validator and make a real one instead
+        let validator = ProtocolVersionValidator::default();
+        let public_keys_validator = PublicKeysValidator::new(bls).unwrap();
+        let identity_facade =
+            IdentityFacade::new(Arc::new(validator), Arc::new(public_keys_validator)).unwrap();
+
+        DashPlatformProtocol(identity_facade)
+    }
+}