@dashevo/wasm-dpp 0.24.0-dev.12 → 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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.24.0-dev.12",
+  "version": "0.24.0-dev.13",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/lib/index.d.ts",
@@ -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.12",
-    "@dashevo/dpp": "0.24.0-dev.12",
+    "@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",
@@ -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_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()
     }

package/src/data_contract/index.rs

@@ -1,6 +1,9 @@
-use dpp::{data_contract::extra::IndexProperty, util::json_schema::Index};
+use dpp::{data_contract::document_type::IndexProperty, util::json_schema::Index};
+use serde::{ser::SerializeMap, Serialize, Serializer};
 use wasm_bindgen::prelude::*;
 
+use crate::{errors::RustConversionError, with_js_error};
+
 #[wasm_bindgen(js_name=IndexProperty)]
 #[derive(Debug, Clone)]
 pub struct IndexPropertyWasm {
@@ -38,6 +41,51 @@ impl From<Index> for IndexDefinitionWasm {
     }
 }
 
+/// Wrapper structure to serialize `Index` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexSerializeJs<'a>(&'a Index);
+
+impl Serialize for IndexSerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("name", &self.0.name)?;
+        if self.0.unique {
+            map.serialize_entry("unique", &true)?;
+        }
+        map.serialize_entry(
+            "properties",
+            &self
+                .0
+                .properties
+                .iter()
+                .map(IndexPropertySerializeJs)
+                .collect::<Vec<_>>(),
+        )?;
+
+        map.end()
+    }
+}
+
+/// Wrapper structure to serialize `InderProperty` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexPropertySerializeJs<'a>(&'a IndexProperty);
+
+impl Serialize for IndexPropertySerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(1))?;
+        let order_str = if self.0.ascending { "asc" } else { "desc" };
+        map.serialize_entry(&self.0.name, order_str)?;
+
+        map.end()
+    }
+}
+
 #[wasm_bindgen(js_class=IndexDefinition)]
 impl IndexDefinitionWasm {
     #[wasm_bindgen(js_name=getName)]
@@ -58,4 +106,11 @@ impl IndexDefinitionWasm {
     pub fn is_unique(&self) -> bool {
         self.inner.unique
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let object = with_js_error!(IndexSerializeJs(&self.inner).serialize(&serializer))?;
+        Ok(object)
+    }
 }

package/src/data_contract/mod.rs

@@ -4,6 +4,7 @@ pub use state_transition::*;
 
 mod data_contract;
 pub mod errors;
+
 mod state_transition;
 
 mod index;

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -14,10 +14,8 @@ use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    buffer::Buffer,
-    errors::{from_dpp_err, RustConversionError},
-    identifier::IdentifierWrapper,
-    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+    buffer::Buffer, errors::from_dpp_err, identifier::IdentifierWrapper, with_js_error,
+    DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=DataContractCreateTransition)]

package/src/data_contract/state_transition/data_contract_create_transition/validation.rs

@@ -14,11 +14,11 @@ pub async fn validate_data_contract_create_transition_state(
     state_transition: DataContractCreateTransitionWasm,
 ) -> Result<ValidationResultWasm, JsValue> {
     let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-    dpp_validate_data_contract_create_transition_state(
+    let validation_result = dpp_validate_data_contract_create_transition_state(
         &wrapped_state_repository,
         &state_transition.into(),
     )
     .await
-    .map(Into::<ValidationResultWasm>::into)
-    .map_err(from_dpp_err)
+    .map_err(from_dpp_err)?;
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
 }

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -14,10 +14,8 @@ use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    buffer::Buffer,
-    errors::{from_dpp_err, RustConversionError},
-    identifier::IdentifierWrapper,
-    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+    buffer::Buffer, errors::from_dpp_err, identifier::IdentifierWrapper, with_js_error,
+    DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=DataContractUpdateTransition)]

package/src/data_contract/state_transition/data_contract_update_transition/validation.rs

@@ -19,13 +19,14 @@ pub async fn validate_data_contract_update_transition_state(
     state_transition: DataContractUpdateTransitionWasm,
 ) -> Result<ValidationResultWasm, JsValue> {
     let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-    dpp_validate_data_contract_update_transition_state(
+    let result = dpp_validate_data_contract_update_transition_state(
         &wrapped_state_repository,
         &state_transition.into(),
     )
     .await
-    .map(Into::into)
-    .map_err(from_dpp_err)
+    .map_err(from_dpp_err)?;
+
+    Ok(result.map(|_| JsValue::undefined()).into())
 }
 
 #[wasm_bindgen(js_name=validateIndicesAreBackwardCompatible)]
@@ -40,7 +41,9 @@ pub fn validate_indices_are_backward_compatible(
         new_documents_schema,
     )?;
 
-    dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
-        .map(Into::into)
-        .map_err(from_protocol_error)
+    let result =
+        dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
+            .map_err(from_protocol_error)?;
+
+    Ok(result.map(|_| JsValue::undefined()).into())
 }

package/src/data_contract_factory/data_contract_factory.rs

@@ -14,7 +14,6 @@ use crate::{
     data_contract::errors::InvalidDataContractError,
     errors::{
         consensus_error::from_consensus_error, from_dpp_err, protocol_error::from_protocol_error,
-        RustConversionError,
     },
     validation::ValidationResultWasm,
     with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
@@ -42,15 +41,14 @@ impl DataContractValidatorWasm {
         DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
     }
 
-    #[wasm_bindgen(js_name=validate)]
+    #[wasm_bindgen]
     pub fn validate(&self, raw_data_contract: JsValue) -> Result<ValidationResultWasm, JsValue> {
         let parameters: DataContractParameters =
             with_js_error!(serde_wasm_bindgen::from_value(raw_data_contract))?;
         let json_object = serde_json::to_value(parameters).expect("Implements Serialize");
-        self.0
-            .validate(&json_object)
-            .map(Into::into)
-            .map_err(from_protocol_error)
+        let validation_result = self.0.validate(&json_object).map_err(from_protocol_error)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }
 

package/src/document/errors/invalid_document_error.rs

@@ -1,7 +1,5 @@
 use thiserror::Error;
 
-use crate::DocumentWasm;
-
 use super::*;
 
 #[wasm_bindgen]
@@ -10,14 +8,17 @@ use super::*;
 pub struct InvalidDocumentError {
     // the point is how we hold all there different types in  the Vector
     errors: Vec<JsValue>,
-    document: DocumentWasm,
+    raw_document: JsValue,
 }
 
-#[wasm_bindgen]
+#[wasm_bindgen(js_class=InvalidDocumentError)]
 impl InvalidDocumentError {
     #[wasm_bindgen(constructor)]
-    pub fn new(document: DocumentWasm, errors: Vec<JsValue>) -> InvalidDocumentError {
-        Self { document, errors }
+    pub fn new(raw_document: JsValue, errors: Vec<JsValue>) -> InvalidDocumentError {
+        Self {
+            raw_document,
+            errors,
+        }
     }
 
     #[wasm_bindgen(js_name=getErrors)]
@@ -25,8 +26,8 @@ impl InvalidDocumentError {
         self.errors.clone()
     }
 
-    #[wasm_bindgen(js_name=getDocument)]
-    pub fn get_document(&self) -> DocumentWasm {
-        self.document.clone()
+    #[wasm_bindgen(js_name=getRawDocument)]
+    pub fn get_document(&self) -> JsValue {
+        self.raw_document.clone()
     }
 }

package/src/document/errors/invalid_initial_revision_error.rs

@@ -18,7 +18,7 @@ impl InvalidInitialRevisionError {
         Self { document }
     }
 
-    #[wasm_bindgen(js_name=getDocumentTransition)]
+    #[wasm_bindgen(js_name=getDocument)]
     pub fn get_document_transition(&self) -> DocumentWasm {
         self.document.clone()
     }

package/src/document/errors/mismatch_owners_ids_error.rs

@@ -1,3 +1,5 @@
+use dpp::prelude::Document;
+use itertools::Itertools;
 use thiserror::Error;
 
 use crate::DocumentWasm;
@@ -7,21 +9,29 @@ use super::*;
 #[wasm_bindgen]
 #[derive(Error, Debug)]
 #[error("Documents have mixed owner ids")]
-pub struct MismatchOwnersIdsError {
+pub struct MismatchOwnerIdsError {
     documents: Vec<DocumentWasm>,
 }
 
 #[wasm_bindgen]
-impl MismatchOwnersIdsError {
+impl MismatchOwnerIdsError {
     #[wasm_bindgen(constructor)]
-    pub fn new(documents: Vec<JsValue>) -> MismatchOwnersIdsError {
+    pub fn new(documents: Vec<JsValue>) -> MismatchOwnerIdsError {
         Self {
             documents: into_vec_of(&documents),
         }
     }
 
-    #[wasm_bindgen(js_name=getDocumentTransition)]
+    #[wasm_bindgen(js_name=getDocuments)]
     pub fn get_documents(&self) -> Vec<JsValue> {
         to_vec_js(self.documents.clone())
     }
 }
+
+impl MismatchOwnerIdsError {
+    pub fn from_documents(documents: Vec<Document>) -> MismatchOwnerIdsError {
+        Self {
+            documents: documents.into_iter().map(DocumentWasm::from).collect_vec(),
+        }
+    }
+}

package/src/document/errors/mod.rs

@@ -1,3 +1,4 @@
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
 pub use document_already_exists_error::*;
@@ -11,7 +12,7 @@ pub use mismatch_owners_ids_error::*;
 pub use no_documents_supplied_error::*;
 
 use crate::errors::consensus_error::from_consensus_error;
-use crate::{utils::*, DocumentWasm};
+use crate::utils::*;
 
 mod document_already_exists_error;
 mod document_not_provided_error;
@@ -24,32 +25,35 @@ mod no_documents_supplied_error;
 
 pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
     match e {
-        DocumentError::DocumentAlreadyExists {
+        DocumentError::DocumentAlreadyExistsError {
             document_transition,
         } => DocumentAlreadyExistsError::new(document_transition).into(),
-        DocumentError::DocumentNotProvided {
+        DocumentError::DocumentNotProvidedError {
             document_transition,
         } => DocumentNotProvidedError::new(document_transition).into(),
 
-        DocumentError::InvalidActionName { actions } => {
+        DocumentError::InvalidActionNameError { actions } => {
             InvalidActionNameError::new(to_vec_js(actions)).into()
         }
-        DocumentError::InvalidDocument { errors, document } => InvalidDocumentError::new(
-            (*document).into(),
+        DocumentError::InvalidDocumentError {
+            errors,
+            raw_document,
+        } => InvalidDocumentError::new(
+            raw_document
+                .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                .expect("Raw Document should be serializable into JsValue"),
             errors.into_iter().map(from_consensus_error).collect(),
         )
         .into(),
-        DocumentError::InvalidDocumentAction {
+        DocumentError::InvalidDocumentActionError {
             document_transition,
         } => InvalidDocumentActionError::new(document_transition).into(),
-        DocumentError::InvalidInitialRevision { document } => {
+        DocumentError::InvalidInitialRevisionError { document } => {
             InvalidInitialRevisionError::new((*document).into()).into()
         }
-        DocumentError::MismatchOwnersIds { documents } => {
-            let documents_wasm: Vec<DocumentWasm> =
-                documents.into_iter().map(DocumentWasm::from).collect();
-            MismatchOwnersIdsError::new(to_vec_js(documents_wasm)).into()
+        DocumentError::MismatchOwnerIdsError { documents } => {
+            MismatchOwnerIdsError::from_documents(documents).into()
         }
-        DocumentError::NotDocumentsSupplied => NotDocumentsSuppliedError::new().into(),
+        DocumentError::NoDocumentsSuppliedError => NoDocumentsSuppliedError::new().into(),
     }
 }

package/src/document/errors/no_documents_supplied_error.rs

@@ -5,17 +5,17 @@ use super::*;
 #[wasm_bindgen]
 #[derive(Error, Debug)]
 #[error("No documents were supplied to state transition")]
-pub struct NotDocumentsSuppliedError {}
+pub struct NoDocumentsSuppliedError {}
 
 #[wasm_bindgen]
-impl NotDocumentsSuppliedError {
+impl NoDocumentsSuppliedError {
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
-        NotDocumentsSuppliedError {}
+        NoDocumentsSuppliedError {}
     }
 }
 
-impl Default for NotDocumentsSuppliedError {
+impl Default for NoDocumentsSuppliedError {
     fn default() -> Self {
         Self::new()
     }