@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/karma.conf.js

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

package/lib/dpp.ts

@@ -0,0 +1,24 @@
+import * as dpp_module from '../wasm/wasm_dpp';
+import { patchConsensusErrors } from './errors/patchConsensusErrors';
+
+patchConsensusErrors();
+
+// While we declared it above, those fields do not hold any values - let's assign them.
+// We need to suppress the compiler here, as he won't be happy about those reassignments.
+// @ts-ignore
+dpp_module.IdentityPublicKey.TYPES = dpp_module.KeyType;
+// @ts-ignore
+dpp_module.IdentityPublicKey.PURPOSES = dpp_module.KeyPurpose;
+// @ts-ignore
+dpp_module.IdentityPublicKey.SECURITY_LEVELS = dpp_module.KeySecurityLevel;
+
+export * from '../wasm/wasm_dpp';
+export * from './errors/AbstractConsensusError';
+export * from './errors/DPPError';
+
+// Declarations written prior to "export *" will overwrite exports
+export declare class IdentityPublicKey extends dpp_module.IdentityPublicKey {
+    static TYPES: typeof dpp_module.KeyType;
+    static PURPOSES: typeof dpp_module.KeyPurpose;
+    static SECURITY_LEVELS: typeof dpp_module.KeySecurityLevel;
+}

package/lib/errors/AbstractConsensusError.ts

@@ -0,0 +1,13 @@
+import { DPPError } from './DPPError'
+
+/**
+ * @abstract
+ */
+export class AbstractConsensusError extends DPPError {
+    /**
+     * @param {string} message
+     */
+    constructor(message: string) {
+        super(message);
+    }
+}

package/lib/errors/DPPError.ts

@@ -0,0 +1,15 @@
+export class DPPError extends Error {
+    name: string;
+    message: string;
+
+    constructor(message: string) {
+        super();
+
+        this.name = this.constructor.name;
+        this.message = message;
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}

package/lib/errors/patchConsensusErrors.ts

@@ -0,0 +1,175 @@
+import * as dpp_module from '../../wasm/wasm_dpp';
+import { extend } from "../utils/extend";
+import { AbstractConsensusError } from "./AbstractConsensusError";
+
+const {
+    ProtocolVersionParsingError,
+    UnsupportedProtocolVersionError,
+    IncompatibleProtocolVersionError,
+    SerializedObjectParsingError,
+    JsonSchemaError,
+    InvalidIdentifierError,
+    DataContractMaxDepthExceedError,
+    DuplicateIndexError,
+    InvalidCompoundIndexError,
+    InvalidDataContractIdError,
+    InvalidIndexedPropertyConstraintError,
+    InvalidIndexPropertyTypeError,
+    SystemPropertyIndexAlreadyPresentError,
+    UndefinedIndexPropertyError,
+    UniqueIndicesLimitReachedError,
+    InconsistentCompoundIndexDataError,
+    InvalidDocumentTransitionActionError,
+    InvalidDocumentTransitionIdError,
+    DataContractNotPresentError,
+    InvalidDocumentTypeError,
+    MissingDataContractIdError,
+    MissingDocumentTransitionActionError,
+    MissingDocumentTransitionTypeError,
+    MissingDocumentTypeError,
+    DuplicatedIdentityPublicKeyError,
+    DuplicatedIdentityPublicKeyIdError,
+    MissingMasterPublicKeyError,
+    IdentityAssetLockProofLockedTransactionMismatchError,
+    IdentityAssetLockTransactionIsNotFoundError,
+    IdentityAssetLockTransactionOutPointAlreadyExistsError,
+    IdentityAssetLockTransactionOutputNotFoundError,
+    InvalidAssetLockProofCoreChainHeightError,
+    InvalidAssetLockProofTransactionHeightError,
+    InvalidIdentityAssetLockTransactionError,
+    InvalidIdentityAssetLockTransactionOutputError,
+    InvalidIdentityPublicKeyDataError,
+    InvalidIdentityPublicKeySecurityLevelError,
+    InvalidStateTransitionTypeError,
+    MissingStateTransitionTypeError,
+    StateTransitionMaxSizeExceededError,
+    IdentityNotFoundError,
+    InvalidIdentityPublicKeyTypeError,
+    InvalidStateTransitionSignatureError,
+    MissingPublicKeyError,
+    BalanceIsNotEnoughError,
+    DataContractAlreadyPresentError,
+    DataTriggerConditionError,
+    DataTriggerExecutionError,
+    DataTriggerInvalidResultError,
+    DocumentAlreadyPresentError,
+    DocumentNotFoundError,
+    DocumentOwnerIdMismatchError,
+    DocumentTimestampsMismatchError,
+    DocumentTimestampWindowViolationError,
+    DuplicateUniqueIndexError,
+    InvalidDocumentRevisionError,
+    IdentityAlreadyExistsError,
+    InvalidJsonSchemaRefError,
+    JsonSchemaCompilationError,
+    DuplicateDocumentTransitionsWithIdsError,
+    DuplicateDocumentTransitionsWithIndicesError,
+    InvalidAssetLockTransactionOutputReturnSizeError,
+    InvalidInstantAssetLockProofError,
+    InvalidInstantAssetLockProofSignatureError,
+    IncompatibleRe2PatternError,
+    InvalidDataContractVersionError,
+    IncompatibleDataContractSchemaError,
+    DataContractImmutablePropertiesUpdateError,
+    DataContractUniqueIndicesChangedError,
+    DuplicateIndexNameError,
+    DataContractInvalidIndexDefinitionUpdateError,
+    DataContractHaveNewUniqueIndexError,
+    IdentityPublicKeyDisabledAtWindowViolationError,
+    IdentityPublicKeyIsReadOnlyError,
+    InvalidIdentityPublicKeyIdError,
+    InvalidIdentityRevisionError,
+    MaxIdentityPublicKeyLimitReachedError,
+    InvalidIdentityKeySignatureError,
+    InvalidSignaturePublicKeySecurityLevelError,
+    PublicKeyIsDisabledError,
+    PublicKeySecurityLevelNotMetError,
+    WrongPublicKeyPurposeError,
+    IdentityPublicKeyIsDisabledError,
+} = dpp_module;
+
+export function patchConsensusErrors() {
+    extend(ProtocolVersionParsingError, AbstractConsensusError);
+    extend(UnsupportedProtocolVersionError, AbstractConsensusError);
+    extend(IncompatibleProtocolVersionError, AbstractConsensusError);
+    extend(SerializedObjectParsingError, AbstractConsensusError);
+    extend(JsonSchemaError, AbstractConsensusError);
+    extend(InvalidIdentifierError, AbstractConsensusError);
+    extend(DataContractMaxDepthExceedError, AbstractConsensusError);
+    extend(DuplicateIndexError, AbstractConsensusError);
+    extend(InvalidCompoundIndexError, AbstractConsensusError);
+    extend(InvalidDataContractIdError, AbstractConsensusError);
+    extend(InvalidIndexedPropertyConstraintError, AbstractConsensusError);
+    extend(InvalidIndexPropertyTypeError, AbstractConsensusError);
+    extend(SystemPropertyIndexAlreadyPresentError, AbstractConsensusError);
+    extend(UndefinedIndexPropertyError, AbstractConsensusError);
+    extend(UniqueIndicesLimitReachedError, AbstractConsensusError);
+    extend(InconsistentCompoundIndexDataError, AbstractConsensusError);
+    extend(InvalidDocumentTransitionActionError, AbstractConsensusError);
+    extend(InvalidDocumentTransitionIdError, AbstractConsensusError);
+    extend(DataContractNotPresentError, AbstractConsensusError);
+    extend(InvalidDocumentTypeError, AbstractConsensusError);
+    extend(MissingDataContractIdError, AbstractConsensusError);
+    extend(MissingDocumentTransitionActionError, AbstractConsensusError);
+    extend(MissingDocumentTransitionTypeError, AbstractConsensusError);
+    extend(MissingDocumentTypeError, AbstractConsensusError);
+    extend(DuplicatedIdentityPublicKeyError, AbstractConsensusError);
+    extend(DuplicatedIdentityPublicKeyIdError, AbstractConsensusError);
+    extend(MissingMasterPublicKeyError, AbstractConsensusError);
+    extend(IdentityAssetLockProofLockedTransactionMismatchError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionIsNotFoundError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionOutPointAlreadyExistsError, AbstractConsensusError);
+    extend(IdentityAssetLockTransactionOutputNotFoundError, AbstractConsensusError);
+    extend(InvalidAssetLockProofCoreChainHeightError, AbstractConsensusError);
+    extend(InvalidAssetLockProofTransactionHeightError, AbstractConsensusError);
+    extend(InvalidIdentityAssetLockTransactionError, AbstractConsensusError);
+    extend(InvalidIdentityAssetLockTransactionOutputError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyDataError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeySecurityLevelError, AbstractConsensusError);
+    extend(InvalidStateTransitionTypeError, AbstractConsensusError);
+    extend(MissingStateTransitionTypeError, AbstractConsensusError);
+    extend(StateTransitionMaxSizeExceededError, AbstractConsensusError);
+    extend(IdentityNotFoundError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyTypeError, AbstractConsensusError);
+    extend(InvalidStateTransitionSignatureError, AbstractConsensusError);
+    extend(MissingPublicKeyError, AbstractConsensusError);
+    extend(BalanceIsNotEnoughError, AbstractConsensusError);
+    extend(DataContractAlreadyPresentError, AbstractConsensusError);
+    extend(DataTriggerConditionError, AbstractConsensusError);
+    extend(DataTriggerExecutionError, AbstractConsensusError);
+    extend(DataTriggerInvalidResultError, AbstractConsensusError);
+    extend(DocumentAlreadyPresentError, AbstractConsensusError);
+    extend(DocumentNotFoundError, AbstractConsensusError);
+    extend(DocumentOwnerIdMismatchError, AbstractConsensusError);
+    extend(DocumentTimestampsMismatchError, AbstractConsensusError);
+    extend(DocumentTimestampWindowViolationError, AbstractConsensusError);
+    extend(DuplicateUniqueIndexError, AbstractConsensusError);
+    extend(InvalidDocumentRevisionError, AbstractConsensusError);
+    extend(IdentityAlreadyExistsError, AbstractConsensusError);
+    extend(InvalidJsonSchemaRefError, AbstractConsensusError);
+    extend(JsonSchemaCompilationError, AbstractConsensusError);
+    extend(DuplicateDocumentTransitionsWithIdsError, AbstractConsensusError);
+    extend(DuplicateDocumentTransitionsWithIndicesError, AbstractConsensusError);
+    extend(InvalidAssetLockTransactionOutputReturnSizeError, AbstractConsensusError);
+    extend(InvalidInstantAssetLockProofError, AbstractConsensusError);
+    extend(InvalidInstantAssetLockProofSignatureError, AbstractConsensusError);
+    extend(IncompatibleRe2PatternError, AbstractConsensusError);
+    extend(InvalidDataContractVersionError, AbstractConsensusError);
+    extend(IncompatibleDataContractSchemaError, AbstractConsensusError);
+    extend(DataContractImmutablePropertiesUpdateError, AbstractConsensusError);
+    extend(DataContractUniqueIndicesChangedError, AbstractConsensusError);
+    extend(DuplicateIndexNameError, AbstractConsensusError);
+    extend(DataContractInvalidIndexDefinitionUpdateError, AbstractConsensusError);
+    extend(DataContractHaveNewUniqueIndexError, AbstractConsensusError);
+    extend(IdentityPublicKeyDisabledAtWindowViolationError, AbstractConsensusError);
+    extend(IdentityPublicKeyIsReadOnlyError, AbstractConsensusError);
+    extend(InvalidIdentityPublicKeyIdError, AbstractConsensusError);
+    extend(InvalidIdentityRevisionError, AbstractConsensusError);
+    extend(MaxIdentityPublicKeyLimitReachedError, AbstractConsensusError);
+    extend(InvalidIdentityKeySignatureError, AbstractConsensusError);
+    extend(InvalidSignaturePublicKeySecurityLevelError, AbstractConsensusError);
+    extend(PublicKeyIsDisabledError, AbstractConsensusError);
+    extend(PublicKeySecurityLevelNotMetError, AbstractConsensusError);
+    extend(WrongPublicKeyPurposeError, AbstractConsensusError);
+    extend(IdentityPublicKeyIsDisabledError, AbstractConsensusError);
+}

package/lib/{patchIdentifier.ts → identifier/patchIdentifier.ts}

@@ -1,4 +1,4 @@
-import * as dpp_module from "../wasm/wasm_dpp";
+import * as dpp_module from "../dpp";
 // import { inspect } from 'util';
 
 export default function (dppModule: typeof dpp_module) {
@@ -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/{index.ts → lib/index.ts}

@@ -1,7 +1,8 @@
-import init, * as dpp_module from './wasm/wasm_dpp';
+import init from '../wasm/wasm_dpp';
+import * as dpp_module from './dpp';
 // @ts-ignore
-import wasmBase from './wasm/wasm_dpp_bg.js';
-import patchIdentifier from "./lib/patchIdentifier";
+import wasmBase from '../wasm/wasm_dpp_bg.js';
+import patchIdentifier from "./identifier/patchIdentifier";
 
 let isInitialized = false;
 
@@ -17,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/expect/expectError.js

@@ -12,12 +12,14 @@ const expectError = {
     const wasmDpp = await loadWasmDpp();
     if (!errorClass) {
       // eslint-disable-next-line no-param-reassign
-      errorClass = wasmDpp.ValidationResult;
+      errorClass = wasmDpp.AbstractConsensusError;
     }
     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));
+    result.getErrors().forEach((error) => {
+      expect(error).to.be.an.instanceOf(errorClass);
+    });
   },
 
   /**

package/lib/test/mocks/getBlsAdapterMock.js

@@ -0,0 +1,36 @@
+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.PublicKey.fromBytes(publicKeyBuffer);
+      } catch (e) {
+        return false;
+      }
+
+      return Boolean(pk);
+    },
+    sign(data, key) {
+      const blsKey = bls.PrivateKey.fromBytes(key, true);
+      const signature = blsKey.sign(data);
+      return Buffer.from(signature.serialize());
+    },
+    verifySignature(signature, data, publicKey) {
+      const { PublicKey, Signature: BlsSignature, AggregationInfo } = bls;
+
+      const blsKey = PublicKey.fromBytes(publicKey);
+
+      const aggregationInfo = AggregationInfo.fromMsg(blsKey, data);
+      const blsSignature = BlsSignature.fromBytesAndAggregationInfo(signature, aggregationInfo);
+
+      return blsSignature.verify();
+    },
+  };
+
+  return blsAdapter;
+};

package/lib/test/utils/newDocumentsContainer.js

@@ -0,0 +1,36 @@
+const { default: loadWasmDpp } = require('../../../dist');
+
+/**
+ * Creates container with documents
+ *
+ * @return {DocumentsContainer}
+ */
+async function newDocumentsContainer(documents) {
+  const {
+    create: createDocuments,
+    replace: replaceDocuments,
+    delete: deleteDocuments,
+  } = documents;
+  const { DocumentsContainer } = await loadWasmDpp();
+
+  const documentsContainer = new DocumentsContainer();
+  if (createDocuments != null) {
+    createDocuments.forEach((document) => {
+      documentsContainer.pushDocumentCreate(document);
+    });
+  }
+  if (replaceDocuments != null) {
+    replaceDocuments.forEach((document) => {
+      documentsContainer.pushDocumentReplace(document);
+    });
+  }
+  if (deleteDocuments != null) {
+    deleteDocuments.forEach((document) => {
+      documentsContainer.pushDocumentDelete(document);
+    });
+  }
+
+  return documentsContainer;
+}
+
+module.exports = newDocumentsContainer;

package/lib/utils/extend.ts

@@ -0,0 +1,6 @@
+export function extend(Derived: any, Base: any) {
+    Object.setPrototypeOf(
+        Derived.prototype,
+        Base.prototype,
+    );
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.11",
+  "version": "0.24.0-dev.13",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/lib/index.d.ts",
   "scripts": {
     "build": "yarn exec scripts/build.sh && webpack",
     "test": "yarn run test:node && yarn run test:browsers",
@@ -30,13 +30,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@dashevo/bls": "~1.0.0-beta.2"
+    "@dashevo/bls": "~1.0.0-beta.2",
+    "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.11",
-    "@dashevo/dpp": "0.24.0-dev.11",
+    "@dashevo/dpns-contract": "0.24.0-dev.13",
+    "@dashevo/dpp": "0.24.0-dev.13",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/node": "^14.6.0",
     "ajv": "^8.6.0",
@@ -53,7 +55,7 @@
     "eslint-config-airbnb-base": "^14.2.1",
     "eslint-plugin-import": "^2.24.2",
     "events": "^3.3.0",
-    "fast-json-patch": "^3.1.0",
+    "fast-json-patch": "^3.1.1",
     "https-browserify": "^1.0.0",
     "json-schema-diff-validator": "^0.4.1",
     "karma": "^6.4.1",
@@ -73,6 +75,7 @@
     "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",

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)]
@@ -66,6 +68,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/data_contract/data_contract.rs

@@ -12,6 +12,7 @@ use dpp::util::string_encoding::Encoding;
 
 use crate::errors::{from_dpp_err, RustConversionError};
 use crate::metadata::MetadataWasm;
+use crate::utils::WithJsError;
 use crate::{bail_js, with_js_error};
 use crate::{buffer::Buffer, identifier::IdentifierWrapper};
 
@@ -34,11 +35,16 @@ impl std::convert::Into<DataContract> for DataContractWasm {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct DataContractParameters {
-    #[serde(rename = "$schema")]
-    schema: String,
-    #[serde(rename = "$id")]
-    id: Vec<u8>,
-    owner_id: Vec<u8>,
+    #[serde(
+        rename = "$schema",
+        skip_serializing_if = "serde_json::Value::is_null",
+        default
+    )]
+    schema: serde_json::Value,
+    #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
+    id: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    owner_id: Option<Vec<u8>>,
     #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
     documents: serde_json::Value,
     #[serde(
@@ -47,8 +53,13 @@ pub(crate) struct DataContractParameters {
         rename = "$defs"
     )]
     defs: serde_json::Value,
-    protocol_version: u32,
-    version: u32,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    protocol_version: serde_json::Value,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    version: serde_json::Value,
+
+    #[serde(flatten)]
+    _extras: serde_json::Value, // Captures excess fields to trigger validation failure later.
 }
 
 #[wasm_bindgen(js_class=DataContract)]
@@ -75,6 +86,11 @@ impl DataContractWasm {
         self.0.id.clone().into()
     }
 
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: IdentifierWrapper) {
+        self.0.id = id.inner();
+    }
+
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
         self.0.owner_id.clone().into()
@@ -276,6 +292,12 @@ impl DataContractWasm {
             .map_err(from_dpp_err)?
             .into())
     }
+
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
+        let data_contract = DataContract::from_cbor(b).with_js_error()?;
+        Ok(data_contract.into())
+    }
 }
 
 #[wasm_bindgen(js_name=DataContractDefaults)]
@@ -288,3 +310,9 @@ impl DataContractDefaults {
         SCHEMA_URI.to_string()
     }
 }
+
+impl DataContractWasm {
+    pub fn inner(&self) -> &DataContract {
+        &self.0
+    }
+}

package/src/data_contract/errors/invalid_data_contract.rs

@@ -10,6 +10,7 @@ pub struct InvalidDataContractError {
 
 #[wasm_bindgen(js_class=InvalidDataContractError)]
 impl InvalidDataContractError {
+    #[wasm_bindgen(constructor)]
     pub fn new(errors: Vec<JsValue>, raw_data_contract: JsValue) -> Self {
         InvalidDataContractError {
             errors,
@@ -26,4 +27,24 @@ impl InvalidDataContractError {
     pub fn get_raw_data_contract(&self) -> JsValue {
         self.raw_data_contract.clone()
     }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        let extended_message = if let Some(error_message) = self
+            .errors
+            .first()
+            .map(|e| Into::<js_sys::Error>::into(e.clone()).message())
+        {
+            let narrowed_message = if self.errors.len() > 1 {
+                format!(" and {} more", self.errors.len() - 1)
+            } else {
+                "".to_owned()
+            };
+            format!(": \"{error_message}\"{narrowed_message}")
+        } else {
+            "".to_owned()
+        };
+
+        format!("Data contract decode error{extended_message}")
+    }
 }

package/src/data_contract/errors/invalid_document_type.rs

@@ -21,7 +21,7 @@ impl InvalidDocumentTypeInDataContractError {
             data_contract,
         }
     }
-    #[wasm_bindgen(js_name = "getDocType")]
+    #[wasm_bindgen(js_name = "getType")]
     pub fn get_doc_type(&self) -> String {
         self.doc_type.clone()
     }