@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/karma.conf.js

@@ -9,6 +9,11 @@ const webpackConfig = require('./webpack.config');
 
 module.exports = (config) => {
   config.set({
+    client: {
+      mocha: {
+        timeout: 5000,
+      },
+    },
     frameworks: ['mocha', 'chai', 'webpack'],
     files: [
       'lib/test/karma/loader.js',

package/lib/identifier/patchIdentifier.ts

@@ -11,8 +11,8 @@ export default function (dppModule: typeof dpp_module) {
     //@ts-ignore
     Object.setPrototypeOf(Identifier.prototype, Buffer.prototype);
 
-    Identifier.prototype.valueOf = function() {
-        return Buffer.from(this.inner());
+    Identifier.prototype.valueOf = function () {
+        return Buffer.from(this.toBytes());
     }
 
     // @ts-ignore
@@ -24,7 +24,7 @@ export default function (dppModule: typeof dpp_module) {
     };
 
     // @ts-ignore
-    Identifier.prototype.inspect = function(...args) {
+    Identifier.prototype.inspect = function (...args) {
         return this.valueOf().inspect(...args);
     }
 
@@ -34,4 +34,5 @@ export default function (dppModule: typeof dpp_module) {
     //  console.log("custom:", inspect.custom);
     //  //@ts-ignore
     //  Identifier.prototype[inspect.custom] = Identifier.prototype.inspect;
-}
+}
+

package/lib/index.ts

@@ -18,7 +18,7 @@ export default async function loadDpp() {
       let wasmUrl = URL.createObjectURL(blob);
       await init(wasmUrl);
       isInitialized = true;
-    }  else {
+    } else {
       dpp_module.initSync(bytes);
       isInitialized = true;
     }

package/lib/test/bootstrap.js

@@ -5,6 +5,7 @@ const dirtyChai = require('dirty-chai');
 const chaiAsPromised = require('chai-as-promised');
 const chaiString = require('chai-string');
 const chaiExclude = require('chai-exclude');
+const crypto = require('crypto');
 
 use(sinonChai);
 use(chaiAsPromised);
@@ -12,6 +13,10 @@ use(dirtyChai);
 use(chaiString);
 use(chaiExclude);
 
+/* eslint-disable */
+// TODO this should be loaded with library - not with tests.
+globalThis.crypto = crypto.webcrypto;
+
 beforeEach(function beforeEach() {
   if (!this.sinonSandbox) {
     this.sinonSandbox = sinon.createSandbox();

package/lib/test/fixtures/getDataContractFixture.js

@@ -0,0 +1,267 @@
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+const JsIdentifier = require('@dashevo/dpp/lib/identifier/Identifier');
+const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
+const { default: loadWasmDpp } = require('../../..');
+let { DataContractFactory, DataContractValidator } = require('../../..');
+
+let randomOwnerId = null;
+
+/**
+ *
+ * @param {Buffer} [ownerId]
+ * @return {Promise<DataContract>}
+ */
+module.exports = async function getDataContractFixture(ownerId = randomOwnerId) {
+  ({ DataContractFactory, DataContractValidator } = await loadWasmDpp());
+
+  if (!randomOwnerId) {
+    randomOwnerId = await generateRandomIdentifierAsync();
+  }
+
+  if (!ownerId) {
+    // eslint-disable-next-line no-param-reassign
+    ownerId = randomOwnerId;
+  }
+
+  const documents = {
+    niceDocument: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['$createdAt'],
+      additionalProperties: false,
+    },
+    prettyDocument: {
+      type: 'object',
+      properties: {
+        lastName: {
+          type: 'string',
+        },
+      },
+      required: ['lastName', '$updatedAt'],
+      additionalProperties: false,
+    },
+    indexedDocument: {
+      type: 'object',
+      indices: [
+        {
+          name: 'index1',
+          properties: [
+            { $ownerId: 'asc' },
+            { firstName: 'asc' },
+          ],
+          unique: true,
+        },
+        {
+          name: 'index2',
+          properties: [
+            { $ownerId: 'asc' },
+            { lastName: 'asc' },
+          ],
+          unique: true,
+        },
+        {
+          name: 'index3',
+          properties: [
+            { lastName: 'asc' },
+          ],
+          unique: false,
+        },
+        {
+          name: 'index4',
+          properties: [
+            { $createdAt: 'asc' },
+            { $updatedAt: 'asc' },
+          ],
+        },
+        {
+          name: 'index5',
+          properties: [
+            { $updatedAt: 'asc' },
+          ],
+        },
+        {
+          name: 'index6',
+          properties: [
+            { $createdAt: 'asc' },
+          ],
+        },
+      ],
+      properties: {
+        firstName: {
+          type: 'string',
+          maxLength: 63,
+        },
+        lastName: {
+          type: 'string',
+          maxLength: 63,
+        },
+        otherProperty: {
+          type: 'string',
+          maxLength: 42,
+        },
+      },
+      required: ['firstName', '$createdAt', '$updatedAt', 'lastName'],
+      additionalProperties: false,
+    },
+    // indexedArray: {
+    //   type: 'object',
+    //   indices: [
+    //     {
+    //       name: 'index1',
+    //       properties: [
+    //         { mentions: 'asc' },
+    //       ],
+    //     },
+    //   ],
+    //   properties: {
+    //     mentions: {
+    //       type: 'array',
+    //       prefixItems: [
+    //         {
+    //           type: 'string',
+    //           maxLength: 100,
+    //         },
+    //       ],
+    //       minItems: 1,
+    //       maxItems: 5,
+    //       items: false,
+    //     },
+    //   },
+    //   additionalProperties: false,
+    // },
+    noTimeDocument: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      additionalProperties: false,
+    },
+    uniqueDates: {
+      type: 'object',
+      indices: [
+        {
+          name: 'index1',
+          properties: [
+            { $createdAt: 'asc' },
+            { $updatedAt: 'asc' },
+          ],
+          unique: true,
+        },
+        {
+          name: 'index2',
+          properties: [
+            { $updatedAt: 'asc' },
+          ],
+        },
+      ],
+      properties: {
+        firstName: {
+          type: 'string',
+        },
+        lastName: {
+          type: 'string',
+        },
+      },
+      required: ['firstName', '$createdAt', '$updatedAt'],
+      additionalProperties: false,
+    },
+    withByteArrays: {
+      type: 'object',
+      indices: [
+        {
+          name: 'index1',
+          properties: [
+            { byteArrayField: 'asc' },
+          ],
+        },
+      ],
+      properties: {
+        byteArrayField: {
+          type: 'array',
+          byteArray: true,
+          maxItems: 16,
+        },
+        identifierField: {
+          type: 'array',
+          byteArray: true,
+          contentMediaType: JsIdentifier.MEDIA_TYPE,
+          minItems: 32,
+          maxItems: 32,
+        },
+      },
+      required: ['byteArrayField'],
+      additionalProperties: false,
+    },
+    optionalUniqueIndexedDocument: {
+      type: 'object',
+      properties: {
+        firstName: {
+          type: 'string',
+          maxLength: 63,
+        },
+        lastName: {
+          type: 'string',
+          maxLength: 63,
+        },
+        country: {
+          type: 'string',
+          maxLength: 63,
+        },
+        city: {
+          type: 'string',
+          maxLength: 63,
+        },
+      },
+      indices: [
+        {
+          name: 'index1',
+          properties: [
+            { firstName: 'asc' },
+          ],
+          unique: true,
+        },
+        {
+          name: 'index2',
+          properties: [
+            { $ownerId: 'asc' },
+            { firstName: 'asc' },
+            { lastName: 'asc' },
+          ],
+          unique: true,
+        },
+        {
+          name: 'index3',
+          properties: [
+            { country: 'asc' },
+            { city: 'asc' },
+          ],
+          unique: true,
+        },
+      ],
+      required: ['firstName', 'lastName'],
+      additionalProperties: false,
+    },
+  };
+
+  const dataContractValidator = new DataContractValidator();
+  const factory = new DataContractFactory(
+    protocolVersion.latestProtocolVersion,
+    dataContractValidator,
+  );
+
+  const dataContract = factory.create(ownerId, documents);
+
+  // dataContract.setDefinitions({
+  //   lastName: {
+  //     type: 'string',
+  //   },
+  // });
+
+  return dataContract;
+};

package/lib/test/fixtures/getDocumentsFixture.js

@@ -0,0 +1,43 @@
+const crypto = require('crypto');
+
+const getDataContractFixture = require('./getDataContractFixture');
+
+const { default: loadWasmDpp } = require('../../..');
+let { DocumentFactory, DocumentValidator, ProtocolVersionValidator } = require('../../..');
+const generateRandomIdentifierAsync = require('../utils/generateRandomIdentifierAsync');
+
+/**
+ * @param {DataContract} [dataContract]
+ * @return {Promise<Document[]>}
+ */
+module.exports = async function getDocumentsFixture(
+  dataContract,
+) {
+  if (!dataContract) {
+    // eslint-disable-next-line no-param-reassign
+    dataContract = await getDataContractFixture();
+  }
+
+  ({ DocumentFactory, DocumentValidator, ProtocolVersionValidator } = await loadWasmDpp());
+
+  const documentValidator = new DocumentValidator(new ProtocolVersionValidator());
+  const factory = new DocumentFactory(1, documentValidator, {});
+
+  const ownerId = await generateRandomIdentifierAsync();
+
+  return [
+    factory.create(dataContract, ownerId, 'niceDocument', { name: 'Cutie' }),
+    factory.create(dataContract, ownerId, 'prettyDocument', { lastName: 'Shiny' }),
+    factory.create(dataContract, ownerId, 'prettyDocument', { lastName: 'Sweety' }),
+    factory.create(dataContract, ownerId, 'indexedDocument', { firstName: 'William', lastName: 'Birkin' }),
+    factory.create(dataContract, ownerId, 'indexedDocument', { firstName: 'Leon', lastName: 'Kennedy' }),
+    factory.create(dataContract, ownerId, 'noTimeDocument', { name: 'ImOutOfTime' }),
+    factory.create(dataContract, ownerId, 'uniqueDates', { firstName: 'John' }),
+    factory.create(dataContract, ownerId, 'indexedDocument', { firstName: 'Bill', lastName: 'Gates' }),
+    factory.create(dataContract, ownerId, 'withByteArrays', {
+      byteArrayField: crypto.randomBytes(10),
+      identifierField: (await generateRandomIdentifierAsync()).toBuffer(),
+    }),
+    factory.create(dataContract, ownerId, 'optionalUniqueIndexedDocument', { firstName: 'Jacques-Yves', lastName: 'Cousteau' }),
+  ];
+};

package/lib/test/mocks/createStateRepositoryMock.js

@@ -0,0 +1,64 @@
+/**
+ * @typedef {createStateRepositoryMock}
+ * @param sinonSandbox
+ * @return {{
+ *    fetchDataContract: *,
+ *    createDataContract: *,
+ *    updateDataContract: *,
+ *     fetchDocuments: *,
+ *     createDocument: *,
+ *     updateDocument: *,
+ *     removeDocument: *,
+ *     fetchTransaction: *,
+ *     fetchIdentity: *,
+ *     createIdentity: *,
+ *     updateIdentityRevision: *,
+ *     disableIdentityKeys: *,
+ *     addKeysToIdentity: *,
+ *     fetchIdentityBalance: *,
+ *     fetchIdentityBalanceWithDebt: *,
+ *     addToIdentityBalance: *,
+ *     addToSystemCredits: *,
+ *     fetchLatestPlatformBlockHeight: *,
+ *     fetchLatestPlatformCoreChainLockedHeight: *,
+ *     verifyInstantLock: *,
+ *     markAssetLockTransactionOutPointAsUsed: *,
+ *     verifyChainLockHeight: *,
+ *     isAssetLockTransactionOutPointAlreadyUsed: *,
+ *     fetchSMLStore: *,
+ *     fetchLatestWithdrawalTransactionIndex: *,
+ *     enqueueWithdrawalTransaction: *,
+ *     fetchLatestPlatformBlockTime: *,
+ * }}
+ */
+module.exports = function createStateRepositoryMock(sinonSandbox) {
+  return {
+    fetchDataContract: sinonSandbox.stub(),
+    createDataContract: sinonSandbox.stub(),
+    updateDataContract: sinonSandbox.stub(),
+    fetchDocuments: sinonSandbox.stub(),
+    createDocument: sinonSandbox.stub(),
+    updateDocument: sinonSandbox.stub(),
+    removeDocument: sinonSandbox.stub(),
+    fetchTransaction: sinonSandbox.stub(),
+    fetchIdentity: sinonSandbox.stub(),
+    createIdentity: sinonSandbox.stub(),
+    addKeysToIdentity: sinonSandbox.stub(),
+    disableIdentityKeys: sinonSandbox.stub(),
+    updateIdentityRevision: sinonSandbox.stub(),
+    addToIdentityBalance: sinonSandbox.stub(),
+    fetchIdentityBalance: sinonSandbox.stub(),
+    fetchIdentityBalanceWithDebt: sinonSandbox.stub(),
+    addToSystemCredits: sinonSandbox.stub(),
+    fetchLatestPlatformBlockHeight: sinonSandbox.stub(),
+    fetchLatestPlatformCoreChainLockedHeight: sinonSandbox.stub(),
+    verifyInstantLock: sinonSandbox.stub(),
+    markAssetLockTransactionOutPointAsUsed: sinonSandbox.stub(),
+    verifyChainLockHeight: sinonSandbox.stub(),
+    isAssetLockTransactionOutPointAlreadyUsed: sinonSandbox.stub(),
+    fetchSMLStore: sinonSandbox.stub(),
+    fetchLatestWithdrawalTransactionIndex: sinonSandbox.stub(),
+    enqueueWithdrawalTransaction: sinonSandbox.stub(),
+    fetchLatestPlatformBlockTime: sinonSandbox.stub(),
+  };
+};

package/lib/test/mocks/getBlsAdapterMock.js

@@ -0,0 +1,51 @@
+const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
+
+module.exports = async function getBlsAdapterMock() {
+  const bls = await BlsSignatures.getInstance();
+
+  const blsAdapter = {
+    validatePublicKey(publicKeyBuffer) {
+      let pk;
+
+      try {
+        pk = bls.G1Element.fromBytes(Uint8Array.from(publicKeyBuffer));
+      } catch (e) {
+        return false;
+      } finally {
+        if (pk) {
+          pk.delete();
+        }
+      }
+
+      return Boolean(pk);
+    },
+    sign(data, key) {
+      const blsKey = bls.PrivateKey.fromBytes(Uint8Array.from(key), true);
+      const signature = bls.BasicSchemeMPL.sign(blsKey, data);
+      const result = Buffer.from(signature.serialize());
+
+      signature.delete();
+      blsKey.delete();
+
+      return result;
+    },
+    verifySignature(signature, data, publicKey) {
+      const { G1Element, G2Element, BasicSchemeMPL } = bls;
+
+      const blsKey = G1Element.fromBytes(Uint8Array.from(publicKey));
+
+      const blsSignature = G2Element.fromBytes(
+        Uint8Array.from(signature),
+      );
+
+      const result = BasicSchemeMPL.verify(blsKey, Uint8Array.from(data), blsSignature);
+
+      blsKey.delete();
+      blsSignature.delete();
+
+      return result;
+    },
+  };
+
+  return blsAdapter;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.12",
+  "version": "0.24.0-dev.14",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/lib/index.d.ts",
@@ -10,8 +10,8 @@
     "test:browsers": "karma start ./karma.conf.js --single-run",
     "test:node": "NODE_ENV=test mocha",
     "webpack": "webpack",
-    "lint": "eslint . && cargo clippy && cargo fmt --check",
-    "lint:fix": "eslint . --fix && cargo clippy --fix && cargo fmt",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "clean": "yarn exec scripts/clean.sh"
   },
   "ultra": {
@@ -30,13 +30,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@dashevo/bls": "~1.0.0-beta.2"
+    "@dashevo/bls": "~1.2.9",
+    "lodash": "^4.17.21",
+    "varint": "^6.0.0"
   },
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^8.0.0",
-    "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dpns-contract": "0.24.0-dev.12",
-    "@dashevo/dpp": "0.24.0-dev.12",
+    "@dashevo/dashcore-lib": "~0.20.0",
+    "@dashevo/dpns-contract": "0.24.0-dev.14",
+    "@dashevo/dpp": "0.24.0-dev.14",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/node": "^14.6.0",
     "ajv": "^8.6.0",
@@ -73,11 +75,12 @@
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "string_decoder": "^1.3.0",
+    "terser-webpack-plugin": "^5.3.1",
     "ts-loader": "^8.0.2",
     "typescript": "^3.9.5",
     "url": "^0.11.0",
     "util": "^0.12.4",
-    "webpack": "^5.59.1",
+    "webpack": "^5.76.1",
     "webpack-cli": "^4.9.1"
   }
 }

package/src/bls_adapter.rs

@@ -1,9 +1,11 @@
 use dpp::dashcore::anyhow::anyhow;
 use dpp::{BlsModule, PublicKeyValidationError};
 use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
 
 #[wasm_bindgen]
 extern "C" {
+    #[derive(Clone)]
     pub type JsBlsAdapter;
 
     #[wasm_bindgen(method)]
@@ -31,6 +33,7 @@ extern "C" {
     ) -> Result<js_sys::Uint8Array, JsValue>;
 }
 
+#[derive(Clone)]
 pub struct BlsAdapter(pub JsBlsAdapter);
 
 impl BlsModule for BlsAdapter {
@@ -66,6 +69,19 @@ impl BlsModule for BlsAdapter {
         self.0
             .sign(data, private_key)
             .map(|arr| arr.to_vec())
-            .map_err(|_v| anyhow!("Can't sign").into())
+            .map_err(|e: JsValue| {
+                let error = e.dyn_into::<js_sys::Error>();
+
+                match error {
+                    Ok(e) => {
+                        let message: String = e
+                            .message()
+                            .as_string()
+                            .unwrap_or_else(|| String::from("Unknown error, can't sign"));
+                        anyhow!(message).into()
+                    }
+                    Err(_) => anyhow!("Unknown error, can't sign").into(),
+                }
+            })
     }
 }

package/src/buffer.rs

@@ -10,6 +10,9 @@ extern "C" {
     #[wasm_bindgen(constructor, js_name = "from")]
     pub fn from_bytes(js_sys: &[u8]) -> Buffer;
 
+    #[wasm_bindgen(constructor, js_name = "from")]
+    pub fn from_bytes_owned(js_sys: Vec<u8>) -> Buffer;
+
     #[wasm_bindgen(constructor, js_name = "from")]
     pub fn from_string(js_sys: String) -> Buffer;
 }