@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0

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

@@ -1,45 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-use dpp::data_contract::state_transition::data_contract_create_transition::apply_data_contract_create_transition_factory::ApplyDataContractCreateTransition;
-use wasm_bindgen::prelude::*;
-
-use crate::{
-    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    DataContractCreateTransitionWasm,
-};
-
-#[wasm_bindgen(js_name=ApplyDataContractCreateTransition)]
-pub struct ApplyDataContractCreateTransitionWasm(
-    ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>,
-);
-
-impl From<ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>>
-    for ApplyDataContractCreateTransitionWasm
-{
-    fn from(wa: ApplyDataContractCreateTransition<ExternalStateRepositoryLikeWrapper>) -> Self {
-        ApplyDataContractCreateTransitionWasm(wa)
-    }
-}
-
-#[wasm_bindgen(js_class=ApplyDataContractCreateTransition)]
-impl ApplyDataContractCreateTransitionWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        state_repository: ExternalStateRepositoryLike,
-    ) -> ApplyDataContractCreateTransitionWasm {
-        let pinned_js_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-        ApplyDataContractCreateTransition::new(Arc::new(pinned_js_state_repository)).into()
-    }
-
-    #[wasm_bindgen(js_name=applyDataContractCreateTransition)]
-    pub async fn apply_data_contract_create_transition(
-        &self,
-        transition: DataContractCreateTransitionWasm,
-    ) -> Result<(), JsError> {
-        self.0
-            .apply_data_contract_create_transition(&transition.into(), None)
-            .await
-            .map_err(|e| e.deref().into())
-    }
-}

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

@@ -1,49 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-use dpp::data_contract::state_transition::data_contract_update_transition::apply_data_contract_update_transition_factory::ApplyDataContractUpdateTransition;
-use wasm_bindgen::prelude::*;
-
-use crate::{
-    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    DataContractUpdateTransitionWasm, StateTransitionExecutionContextWasm,
-};
-
-#[wasm_bindgen(js_name=ApplyDataContractUpdateTransition)]
-pub struct ApplyDataContractUpdateTransitionWasm(
-    ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>,
-);
-
-impl From<ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>>
-    for ApplyDataContractUpdateTransitionWasm
-{
-    fn from(wa: ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>) -> Self {
-        ApplyDataContractUpdateTransitionWasm(wa)
-    }
-}
-
-#[wasm_bindgen(js_class=ApplyDataContractUpdateTransition)]
-impl ApplyDataContractUpdateTransitionWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        state_repository: ExternalStateRepositoryLike,
-    ) -> ApplyDataContractUpdateTransitionWasm {
-        let pinned_js_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-        ApplyDataContractUpdateTransition::new(Arc::new(pinned_js_state_repository)).into()
-    }
-
-    #[wasm_bindgen(js_name=applyDataContractUpdateTransition)]
-    pub async fn apply_data_contract_update_transition(
-        &self,
-        transition: DataContractUpdateTransitionWasm,
-        execution_context: &StateTransitionExecutionContextWasm,
-    ) -> Result<(), JsError> {
-        self.0
-            .apply_data_contract_update_transition(
-                &transition.into(),
-                &execution_context.to_owned().into(),
-            )
-            .await
-            .map_err(|e| e.deref().into())
-    }
-}

package/src/decode_protocol_entity.rs

@@ -1,25 +0,0 @@
-use js_sys::Array;
-
-use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::JsValue;
-
-#[wasm_bindgen(js_name=decodeProtocolEntity)]
-pub fn decode_protocol_entity(_buffer: Vec<u8>) -> Result<Array, JsValue> {
-    // TODO(v0.24-backport): revisit.
-    //   This code was not used anywhere but js-drive and wallet-lib.
-    //   In wallet-lib it is replaceable.
-    todo!()
-    // let (protocol_version, value) = DecodeProtocolEntity::decode_protocol_entity_to_value(buffer)
-    //     .map_err(from_protocol_error)?;
-    //
-    // let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-    // let js_value = value
-    //     .try_to_validating_json()
-    //     .map_err(|e| from_protocol_error(ProtocolError::ValueError(e)))?
-    //     .serialize(&serializer)
-    //     .map_err(|e| from_protocol_error(ProtocolError::EncodingError(e.to_string())))?;
-    // Ok(Array::from_iter(vec![
-    //     JsValue::from(protocol_version),
-    //     js_value,
-    // ]))
-}

package/src/document/state_transition/document_batch_transition/apply_document_batch_transition.rs

@@ -1,25 +0,0 @@
-use dpp::document::state_transition::documents_batch_transition::apply_documents_batch_transition_factory::{apply_documents_batch_transition};
-use wasm_bindgen::prelude::*;
-
-use crate::{
-    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    utils::WithJsError,
-    DocumentsBatchTransitionWasm, StateTransitionExecutionContextWasm,
-};
-
-#[wasm_bindgen(js_name=applyDocumentsBatchTransition)]
-pub async fn apply_documents_batch_transition_wasm(
-    state_repository: ExternalStateRepositoryLike,
-    transition: &DocumentsBatchTransitionWasm,
-    execution_context: &StateTransitionExecutionContextWasm,
-) -> Result<(), JsValue> {
-    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-
-    apply_documents_batch_transition(
-        &wrapped_state_repository,
-        &transition.0,
-        &execution_context.to_owned().into(),
-    )
-    .await
-    .with_js_error()
-}

package/test/integration/ajv/keywords/byteArray/addByteArrayKeyword.spec.js

@@ -1,148 +0,0 @@
-const { default: Ajv } = require('ajv');
-
-const addByteArrayKeyword = require('@dashevo/dpp/lib/ajv/keywords/byteArray/addByteArrayKeyword');
-const byteArray = require('@dashevo/dpp/lib/ajv/keywords/byteArray/byteArray');
-
-describe('addByteArrayKeyword', () => {
-  let ajv;
-
-  beforeEach(() => {
-    ajv = new Ajv();
-  });
-
-  it('should add byteArray keyword', () => {
-    addByteArrayKeyword(ajv);
-
-    expect(
-      ajv.getKeyword('byteArray'),
-    ).to.deep.equal(byteArray);
-  });
-
-  describe('byteArray', () => {
-    beforeEach(() => {
-      addByteArrayKeyword(ajv);
-    });
-
-    describe('compilation', () => {
-      it('should be used with array type', () => {
-        const schema = {
-          type: 'string',
-          byteArray: true,
-        };
-
-        ajv.validate(schema, Buffer.alloc(0));
-
-        expect(ajv.errors).to.have.lengthOf(1);
-        expect(ajv.errors[0].keyword).to.equal('type');
-        expect(ajv.errors[0].params.type).to.equal('string');
-      });
-
-      it('should not be used with `items` keyword', () => {
-        const schema = {
-          type: 'array',
-          byteArray: true,
-          items: {
-            type: 'string',
-          },
-        };
-
-        try {
-          ajv.validate(schema, Buffer.alloc(0));
-
-          expect.fail('should fail with keyword schema error');
-        } catch (e) {
-          expect(e.message).to.equal('\'byteArray\' should not be used with \'items\'');
-        }
-      });
-
-      it('should be boolean', () => {
-        const schema = {
-          type: 'array',
-          byteArray: 'something',
-        };
-
-        try {
-          ajv.validate(schema, Buffer.alloc(0));
-
-          expect.fail('should fail with keyword schema error');
-        } catch (e) {
-          expect(e.message).to.equal('keyword "byteArray" value is invalid at path "#": data must be boolean');
-        }
-      });
-
-      it('should have value of true', () => {
-        const schema = {
-          type: 'array',
-          byteArray: false,
-        };
-
-        try {
-          ajv.validate(schema, Buffer.alloc(0));
-
-          expect.fail('should fail with keyword schema error');
-        } catch (e) {
-          expect(e.message).to.equal('keyword "byteArray" value is invalid at path "#": data must be equal to constant');
-        }
-      });
-    });
-
-    describe('validation', () => {
-      it('should accept array of integers', () => {
-        const schema = {
-          type: 'array',
-          byteArray: true,
-        };
-
-        ajv.validate(schema, ['string']);
-
-        expect(ajv.errors).to.have.lengthOf(2);
-
-        const [error, byteArrayError] = ajv.errors;
-
-        expect(error.keyword).to.equal('type');
-        expect(error.schemaPath).to.equal('#/byteArray/items/type');
-        expect(error.message).to.equal('must be integer');
-
-        expect(byteArrayError.keyword).to.equal('byteArray');
-      });
-
-      it('should accept array of integers not less than 0', () => {
-        const schema = {
-          type: 'array',
-          byteArray: true,
-        };
-
-        ajv.validate(schema, [-1]);
-
-        expect(ajv.errors).to.have.lengthOf(2);
-
-        const [error, byteArrayError] = ajv.errors;
-
-        expect(error.keyword).to.equal('minimum');
-        expect(error.schemaPath).to.equal('#/byteArray/items/minimum');
-        expect(error.message).to.equal('must be >= 0');
-
-        expect(byteArrayError.keyword).to.equal('byteArray');
-      });
-
-      it('should accept array of integers not greater than 255', () => {
-        const schema = {
-          type: 'array',
-          byteArray: true,
-        };
-
-        ajv.validate(schema, [0, 256]);
-
-        expect(ajv.errors).to.have.lengthOf(2);
-
-        const [error, byteArrayError] = ajv.errors;
-
-        expect(error.keyword).to.equal('maximum');
-        expect(error.schemaPath).to.equal('#/byteArray/items/maximum');
-        expect(error.message).to.equal('must be <= 255');
-
-        expect(byteArrayError.keyword).to.equal('byteArray');
-      });
-    });
-  });
-});

package/test/integration/util/generateEntropy.spec.js

@@ -1,17 +0,0 @@
-const { generate: generateEntropy } = require('@dashevo/dpp/lib/util/entropyGenerator');
-
-describe('generateEntropy', () => {
-  it('should generate a byte array of length 32', () => {
-    const entropy = generateEntropy();
-
-    expect(Buffer.isBuffer(entropy)).to.be.true();
-    expect(entropy.byteLength).to.be.equal(32);
-  });
-
-  it('should generate random byte array', () => {
-    const randomBuffer = generateEntropy();
-    const secondRandomBuffer = generateEntropy();
-
-    expect(randomBuffer).to.not.deep.equal(secondRandomBuffer);
-  });
-});

package/test/integration/util/serializer.spec.js

@@ -1,24 +0,0 @@
-const { encode } = require('@dashevo/dpp/lib/util/serializer');
-
-const DataSerializationError = require('@dashevo/dpp/lib/util/errors/MaxEncodedBytesReachedError');
-
-describe('serializer', function main() {
-  this.timeout(10000);
-
-  describe('#encode', () => {
-    it('should throw an error if payload is larger that 16 Kb', () => {
-      const payload = {};
-      for (let i = 0; i < 10000; i++) {
-        payload[i] = i;
-      }
-
-      try {
-        encode(payload);
-        expect.fail('Error was not thrown');
-      } catch (e) {
-        expect(e).to.be.an.instanceOf(DataSerializationError);
-        expect(e.getPayload()).to.deep.equal(payload);
-      }
-    });
-  });
-});

package/test/unit/decodeProtocolEntityFactory.spec.js

@@ -1,69 +0,0 @@
-const varint = require('varint');
-const { encode } = require('@dashevo/dpp/lib/util/serializer');
-
-let { decodeProtocolEntity, ProtocolVersionParsingError, SerializedObjectParsingError } = require('../..');
-const { default: loadWasmDpp } = require('../..');
-
-describe('decodeProtocolEntityFactory', () => {
-  let parsedProtocolVersion;
-  let entityBuffer;
-  let protocolVersionBuffer;
-  let rawEntity;
-  let buffer;
-
-  beforeEach(async () => {
-    parsedProtocolVersion = 0;
-
-    protocolVersionBuffer = Buffer.from(varint.encode(parsedProtocolVersion));
-
-    rawEntity = { test: 'successful' };
-    entityBuffer = encode(rawEntity);
-
-    buffer = Buffer.concat([protocolVersionBuffer, entityBuffer]);
-
-    ({
-      decodeProtocolEntity,
-      ProtocolVersionParsingError,
-      SerializedObjectParsingError,
-    } = await loadWasmDpp());
-  });
-
-  it('should throw ProtocolVersionParsingError if can\'t parse protocol version', () => {
-    buffer = Buffer.alloc(0);
-
-    try {
-      decodeProtocolEntity(buffer);
-
-      expect.fail('should throw ProtocolVersionParsingError');
-    } catch (e) {
-      expect(e).to.be.an.instanceOf(ProtocolVersionParsingError);
-
-      expect(e.getParsingError()).to.equals('protocol version could not be decoded as a varint');
-      expect(e.getCode()).to.equal(1000);
-    }
-  });
-
-  it('should throw SerializedObjectParsingError if entity decoding fails', () => {
-    entityBuffer = Buffer.from('invalid');
-
-    buffer = Buffer.concat([protocolVersionBuffer, entityBuffer]);
-
-    try {
-      decodeProtocolEntity(buffer);
-
-      expect.fail('should throw SerializedObjectParsingError');
-    } catch (e) {
-      expect(e).to.be.an.instanceOf(SerializedObjectParsingError);
-
-      expect(e.getParsingError()).to.equals('Io(Error { kind: UnexpectedEof, message: "failed to fill whole buffer" })');
-      expect(e.getCode()).to.equal(1001);
-    }
-  });
-
-  it('should decode protocol version and entity successfully', () => {
-    const [protocolVersion, actualRawEntity] = decodeProtocolEntity(buffer);
-
-    expect(protocolVersion).to.equal(parsedProtocolVersion);
-    expect(rawEntity).to.deep.equal(actualRawEntity);
-  });
-});

package/test/unit/identity/errors/InvalidIdentityError.spec.js

@@ -1,46 +0,0 @@
-const InvalidIdentityError = require('@dashevo/dpp/lib/identity/errors/InvalidIdentityError');
-const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
-
-describe('InvalidIdentityError', () => {
-  let rawIdentity;
-  let error;
-
-  beforeEach(() => {
-    error = new Error('Some error');
-
-    const identity = getIdentityFixture();
-    rawIdentity = identity.toObject();
-  });
-
-  it('should return errors', () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.getErrors()).to.deep.equal(errors);
-  });
-
-  it('should return Identity', async () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.getRawIdentity()).to.deep.equal(rawIdentity);
-  });
-
-  it('should contain message for 1 error', async () => {
-    const errors = [error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.message).to.equal(`Invalid Identity: "${error.message}"`);
-  });
-
-  it('should contain message for multiple errors', async () => {
-    const errors = [error, error];
-
-    const invalidIdentityError = new InvalidIdentityError(errors, rawIdentity);
-
-    expect(invalidIdentityError.message).to.equal(`Invalid Identity: "${error.message}" and 1 more`);
-  });
-});

package/test/unit/stateTransition/errors/InvalidStateTransitionError.spec.js

@@ -1,51 +0,0 @@
-const InvalidStateTransitionError = require('@dashevo/dpp/lib/stateTransition/errors/InvalidStateTransitionError');
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-
-describe('InvalidStateTransitionError', () => {
-  let rawStateTransition;
-  let error;
-
-  beforeEach(() => {
-    error = new Error('Some error');
-
-    const dataContract = getDataContractFixture();
-    const dataContractCreateTransition = new DataContractCreateTransition({
-      dataContract: dataContract.toObject(),
-      entropy: dataContract.getEntropy(),
-    });
-    rawStateTransition = dataContractCreateTransition.toObject();
-  });
-
-  it('should return errors', () => {
-    const errors = [error];
-
-    const invalidStateTransitionError = new InvalidStateTransitionError(errors, rawStateTransition);
-
-    expect(invalidStateTransitionError.getErrors()).to.deep.equal(errors);
-  });
-
-  it('should return State Transition', async () => {
-    const errors = [error];
-
-    const invalidStateTransitionError = new InvalidStateTransitionError(errors, rawStateTransition);
-
-    expect(invalidStateTransitionError.getRawStateTransition()).to.deep.equal(rawStateTransition);
-  });
-
-  it('should contain message for 1 error', async () => {
-    const errors = [error];
-
-    const invalidStateTransitionError = new InvalidStateTransitionError(errors, rawStateTransition);
-
-    expect(invalidStateTransitionError.message).to.equal(`Invalid State Transition: "${error.message}"`);
-  });
-
-  it('should contain message for multiple errors', async () => {
-    const errors = [error, error];
-
-    const invalidStateTransitionError = new InvalidStateTransitionError(errors, rawStateTransition);
-
-    expect(invalidStateTransitionError.message).to.equal(`Invalid State Transition: "${error.message}" and 1 more`);
-  });
-});