@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/stateTransition/createStateTransitionFactory.spec.js

@@ -0,0 +1,72 @@
+const createStateTransitionFactory = require('../../../lib/stateTransition/createStateTransitionFactory');
+
+const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const DocumentsBatchTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
+
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const getDocumentTranstionsFixture = require('../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+
+const InvalidStateTransitionTypeError = require('../../../lib/stateTransition/errors/InvalidStateTransitionTypeError');
+
+describe('createStateTransitionFactory', () => {
+  let createStateTransition;
+  let stateRepositoryMock;
+  let dataContract;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    createStateTransition = createStateTransitionFactory(stateRepositoryMock);
+  });
+
+  it('should return DataContractCreateTransition if type is DATA_CONTRACT_CREATE', async () => {
+    const stateTransition = new DataContractCreateTransition({
+      dataContract: dataContract.toObject(),
+      entropy: dataContract.getEntropy(),
+    });
+
+    const result = await createStateTransition(stateTransition.toObject());
+
+    expect(result).to.be.instanceOf(DataContractCreateTransition);
+    expect(result.getDataContract().toObject()).to.deep.equal(dataContract.toObject());
+  });
+
+  it('should return DocumentsBatchTransition if type is DOCUMENTS', async () => {
+    const documents = getDocumentsFixture(dataContract);
+    const documentTransitions = getDocumentTranstionsFixture({
+      create: documents,
+    });
+
+    const stateTransition = new DocumentsBatchTransition({
+      ownerId: getDocumentsFixture.ownerId,
+      contractId: dataContract.getId(),
+      transitions: documentTransitions.map((t) => t.toObject()),
+    }, [dataContract]);
+
+    const result = await createStateTransition(stateTransition.toObject());
+
+    expect(result).to.be.instanceOf(DocumentsBatchTransition);
+    expect(result.getTransitions().map((t) => t.toObject())).to.have.deep.members(
+      documentTransitions.map((t) => t.toObject()),
+    );
+  });
+
+  it('should throw InvalidStateTransitionTypeError if type is invalid', async () => {
+    const rawStateTransition = {
+      type: 666,
+    };
+
+    try {
+      await createStateTransition(rawStateTransition);
+
+      expect.fail('InvalidStateTransitionTypeError is not thrown');
+    } catch (e) {
+      expect(e).to.be.an.instanceOf(InvalidStateTransitionTypeError);
+      expect(e.getType()).to.equal(rawStateTransition.type);
+    }
+  });
+});

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

@@ -0,0 +1,51 @@
+const InvalidStateTransitionError = require('../../../../lib/stateTransition/errors/InvalidStateTransitionError');
+const DataContractCreateTransition = require('../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const getDataContractFixture = require('../../../../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`);
+  });
+});

package/test/unit/stateTransition/validation/validateStateTransitionBasicFactory.spec.js

@@ -0,0 +1,138 @@
+const validateStateTransitionBasicFactory = require('../../../../lib/stateTransition/validation/validateStateTransitionBasicFactory');
+
+const DataContractFactory = require('../../../../lib/dataContract/DataContractFactory');
+
+const stateTransitionTypes = require('../../../../lib/stateTransition/stateTransitionTypes');
+
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+
+const StateTransitionMaxSizeExceededError = require('../../../../lib/errors/consensus/basic/stateTransition/StateTransitionMaxSizeExceededError');
+
+const {
+  expectValidationError,
+} = require('../../../../lib/test/expect/expectError');
+
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+
+const MissingStateTransitionTypeError = require('../../../../lib/errors/consensus/basic/stateTransition/MissingStateTransitionTypeError');
+const InvalidStateTransitionTypeError = require('../../../../lib/errors/consensus/basic/stateTransition/InvalidStateTransitionTypeError');
+const createDPPMock = require('../../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../../lib/test/mocks/SomeConsensusError');
+const IdentityPublicKey = require('../../../../lib/identity/IdentityPublicKey');
+
+describe('validateStateTransitionBasicFactory', () => {
+  let validateStateTransitionBasic;
+  let validationFunctionMock;
+  let rawStateTransition;
+  let dataContract;
+  let dataContractFactory;
+  let createStateTransitionMock;
+  let stateTransition;
+
+  beforeEach(async function beforeEach() {
+    validationFunctionMock = this.sinonSandbox.stub();
+
+    const validationFunctionsByType = {
+      [stateTransitionTypes.DATA_CONTRACT_CREATE]: validationFunctionMock,
+    };
+
+    dataContract = getDataContractFixture();
+
+    const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
+
+    dataContractFactory = new DataContractFactory(createDPPMock(), undefined);
+
+    stateTransition = dataContractFactory.createDataContractCreateTransition(dataContract);
+    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+
+    rawStateTransition = stateTransition.toObject();
+
+    createStateTransitionMock = this.sinonSandbox.stub().resolves(stateTransition);
+
+    validateStateTransitionBasic = validateStateTransitionBasicFactory(
+      validationFunctionsByType,
+      createStateTransitionMock,
+    );
+  });
+
+  it('should return invalid result if ST type is missing', async () => {
+    delete rawStateTransition.type;
+
+    const result = await validateStateTransitionBasic(rawStateTransition);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.instanceof(MissingStateTransitionTypeError);
+
+    expect(validationFunctionMock).to.not.be.called();
+  });
+
+  it('should return invalid result if ST type is not valid', async () => {
+    rawStateTransition.type = 666;
+
+    const result = await validateStateTransitionBasic(rawStateTransition);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.instanceof(InvalidStateTransitionTypeError);
+
+    expect(validationFunctionMock).to.not.be.called();
+  });
+
+  it('should return invalid result if ST is invalid against validation function', async () => {
+    const extensionError = new SomeConsensusError('test');
+    const extensionResult = new ValidationResult([
+      extensionError,
+    ]);
+
+    validationFunctionMock.returns(extensionResult);
+
+    const result = await validateStateTransitionBasic(rawStateTransition);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.equal(extensionError);
+
+    expect(validationFunctionMock).to.be.calledOnceWith(rawStateTransition);
+  });
+
+  it('should return invalid result if ST size is more than 16 kb', async () => {
+    const validationFunctionResult = new ValidationResult();
+
+    validationFunctionMock.returns(validationFunctionResult);
+
+    // generate big state transition
+    for (let i = 0; i < 500; i++) {
+      stateTransition.dataContract.documents[`anotherContract${i}`] = rawStateTransition.dataContract.documents.niceDocument;
+    }
+
+    const result = await validateStateTransitionBasic(
+      rawStateTransition,
+    );
+
+    expectValidationError(result, StateTransitionMaxSizeExceededError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1045);
+  });
+
+  it('should return valid result', async () => {
+    const extensionResult = new ValidationResult();
+
+    validationFunctionMock.returns(extensionResult);
+
+    const result = await validateStateTransitionBasic(rawStateTransition);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(validationFunctionMock).to.be.calledOnceWith(rawStateTransition);
+  });
+});

package/test/unit/stateTransition/validation/validateStateTransitionFeeFactory.spec.js

@@ -0,0 +1,372 @@
+const validateStateTransitionFeeFactory = require('../../../../lib/stateTransition/validation/validateStateTransitionFeeFactory');
+
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+const getDocumentsFixture = require('../../../../lib/test/fixtures/getDocumentsFixture');
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const getDocumentTransitionsFixture = require('../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+const getIdentityTopUpTransitionFixture = require('../../../../lib/test/fixtures/getIdentityTopUpTransitionFixture');
+
+const DataContractCreateTransition = require('../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const DocumentsBatchTransition = require('../../../../lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
+
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+
+const IdentityBalanceIsNotEnoughError = require('../../../../lib/errors/consensus/fee/BalanceIsNotEnoughError');
+const InvalidStateTransitionTypeError = require('../../../../lib/stateTransition/errors/InvalidStateTransitionTypeError');
+
+const { RATIO } = require('../../../../lib/identity/creditsConverter');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('validateStateTransitionFeeFactory', () => {
+  let stateRepositoryMock;
+  let validateStateTransitionFee;
+  let identity;
+  let dataContract;
+  let calculateStateTransitionFeeMock;
+  let fetchAssetLockTransactionOutputMock;
+
+  beforeEach(function beforeEach() {
+    identity = getIdentityFixture();
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchIdentity.resolves(identity);
+
+    const output = getIdentityCreateTransitionFixture().getAssetLockProof().getOutput();
+
+    calculateStateTransitionFeeMock = this.sinonSandbox.stub().returns(42);
+    fetchAssetLockTransactionOutputMock = this.sinonSandbox.stub().resolves(output);
+
+    validateStateTransitionFee = validateStateTransitionFeeFactory(
+      stateRepositoryMock,
+      calculateStateTransitionFeeMock,
+      fetchAssetLockTransactionOutputMock,
+    );
+
+    dataContract = getDataContractFixture();
+  });
+
+  describe('DataContractCreateTransition', () => {
+    let dataContractCreateTransition;
+
+    beforeEach(() => {
+      dataContractCreateTransition = new DataContractCreateTransition({
+        dataContract: dataContract.toObject(),
+        entropy: dataContract.getEntropy(),
+      });
+    });
+
+    it('should return invalid result if balance is not enough', async () => {
+      identity.balance = 1;
+
+      const result = await validateStateTransitionFee(dataContractCreateTransition);
+
+      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(3000);
+      expect(error.getBalance()).to.equal(identity.balance);
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        dataContract.getOwnerId(),
+        dataContractCreateTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        dataContractCreateTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    });
+
+    it('should return valid result', async () => {
+      identity.balance = 42;
+
+      const result = await validateStateTransitionFee(dataContractCreateTransition);
+
+      expect(result.isValid()).to.be.true();
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        dataContract.getOwnerId(),
+        dataContractCreateTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        dataContractCreateTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    });
+  });
+
+  describe('DocumentsBatchTransition', () => {
+    let documentsBatchTransition;
+
+    beforeEach(() => {
+      const documents = getDocumentsFixture(dataContract);
+
+      const documentTransitions = getDocumentTransitionsFixture({
+        create: documents,
+      });
+
+      documentsBatchTransition = new DocumentsBatchTransition({
+        ownerId: getDocumentsFixture.ownerId,
+        contractId: dataContract.getId(),
+        transitions: documentTransitions.map((t) => t.toObject()),
+      }, [dataContract]);
+    });
+
+    it('should return invalid result if balance is not enough', async () => {
+      identity.balance = 1;
+
+      const result = await validateStateTransitionFee(documentsBatchTransition);
+
+      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(3000);
+      expect(error.getBalance()).to.equal(identity.balance);
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        getDocumentsFixture.ownerId,
+        documentsBatchTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        documentsBatchTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    });
+
+    it('should return valid result', async () => {
+      identity.balance = 42;
+
+      const result = await validateStateTransitionFee(documentsBatchTransition);
+
+      expect(result.isValid()).to.be.true();
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        getDocumentsFixture.ownerId,
+        documentsBatchTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        documentsBatchTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    });
+
+    it('should not increase balance on dry run', async () => {
+      documentsBatchTransition.getExecutionContext().enableDryRun();
+
+      const result = await validateStateTransitionFee(documentsBatchTransition);
+
+      documentsBatchTransition.getExecutionContext().disableDryRun();
+
+      expect(result.isValid()).to.be.true();
+
+      expect(calculateStateTransitionFeeMock).to.be.not.called();
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        getDocumentsFixture.ownerId,
+        documentsBatchTransition.getExecutionContext(),
+      );
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    });
+  });
+
+  describe('IdentityCreateStateTransition', () => {
+    let identityCreateTransition;
+    let outputAmount;
+
+    beforeEach(() => {
+      identityCreateTransition = getIdentityCreateTransitionFixture();
+
+      const { satoshis } = identityCreateTransition
+        .getAssetLockProof()
+        .getOutput();
+
+      outputAmount = satoshis * RATIO;
+    });
+
+    it('should return invalid result if asset lock output amount is not enough', async () => {
+      calculateStateTransitionFeeMock.returns(outputAmount + 1);
+
+      const result = await validateStateTransitionFee(identityCreateTransition);
+
+      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(3000);
+      expect(error.getBalance()).to.equal(outputAmount);
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.not.called();
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        identityCreateTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityCreateTransition.getAssetLockProof(),
+        identityCreateTransition.getExecutionContext(),
+      );
+    });
+
+    it('should return valid result', async () => {
+      calculateStateTransitionFeeMock.returns(outputAmount);
+
+      const result = await validateStateTransitionFee(identityCreateTransition);
+
+      expect(result.isValid()).to.be.true();
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.not.called();
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        identityCreateTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityCreateTransition.getAssetLockProof(),
+        identityCreateTransition.getExecutionContext(),
+      );
+    });
+
+    it('should not increase balance on dry run', async () => {
+      identityCreateTransition.getExecutionContext().enableDryRun();
+
+      const result = await validateStateTransitionFee(identityCreateTransition);
+
+      identityCreateTransition.getExecutionContext().disableDryRun();
+
+      expect(result.isValid()).to.be.true();
+
+      expect(calculateStateTransitionFeeMock).to.be.not.called();
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityCreateTransition.getAssetLockProof(),
+        identityCreateTransition.getExecutionContext(),
+      );
+    });
+  });
+
+  describe('IdentityTopUpTransition', () => {
+    let identityTopUpTransition;
+    let outputAmount;
+
+    beforeEach(() => {
+      identityTopUpTransition = getIdentityTopUpTransitionFixture();
+
+      const { satoshis } = identityTopUpTransition
+        .getAssetLockProof()
+        .getOutput();
+
+      outputAmount = satoshis * RATIO;
+    });
+
+    it('should return invalid result if sum of balance and asset lock output amount is not enough', async () => {
+      identity.balance = 1;
+
+      calculateStateTransitionFeeMock.returns(outputAmount + 2);
+
+      const result = await validateStateTransitionFee(identityTopUpTransition);
+
+      expectValidationError(result, IdentityBalanceIsNotEnoughError);
+
+      const [error] = result.getErrors();
+
+      expect(error.getCode()).to.equal(3000);
+      expect(error.getBalance()).to.equal(outputAmount + identity.balance);
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getIdentityId(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        identityTopUpTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getAssetLockProof(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+    });
+
+    it('should return valid result', async () => {
+      identity.balance = 41;
+
+      calculateStateTransitionFeeMock.returns(outputAmount - 1);
+
+      const result = await validateStateTransitionFee(identityTopUpTransition);
+
+      expect(result.isValid()).to.be.true();
+
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getIdentityId(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+
+      expect(calculateStateTransitionFeeMock).to.be.calledOnceWithExactly(
+        identityTopUpTransition,
+      );
+
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getAssetLockProof(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+    });
+
+    it('should not increase balance on dry run', async () => {
+      identityTopUpTransition.getExecutionContext().enableDryRun();
+
+      const result = await validateStateTransitionFee(identityTopUpTransition);
+
+      identityTopUpTransition.getExecutionContext().disableDryRun();
+
+      expect(result.isValid()).to.be.true();
+
+      expect(calculateStateTransitionFeeMock).to.be.not.called();
+      expect(fetchAssetLockTransactionOutputMock).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getAssetLockProof(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+      expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+        identityTopUpTransition.getIdentityId(),
+        identityTopUpTransition.getExecutionContext(),
+      );
+    });
+  });
+
+  it('should throw InvalidStateTransitionTypeError on invalid State Transition', async function it() {
+    const rawStateTransitionMock = {
+      data: 'sample data',
+      type: -1,
+    };
+
+    const stateTransitionMock = {
+      getType: this.sinonSandbox.stub().returns(rawStateTransitionMock.type),
+      toBuffer: this.sinonSandbox.stub().returns(Buffer.alloc(0)),
+      toObject: this.sinonSandbox.stub().returns(rawStateTransitionMock),
+      getExecutionContext: this.sinonSandbox.stub().returns(new StateTransitionExecutionContext()),
+    };
+
+    try {
+      await validateStateTransitionFee(stateTransitionMock);
+
+      expect.fail('should throw InvalidStateTransitionTypeError');
+    } catch (error) {
+      expect(error).to.be.an.instanceOf(InvalidStateTransitionTypeError);
+      expect(error.getType()).to.equal(rawStateTransitionMock.type);
+
+      expect(calculateStateTransitionFeeMock).to.not.be.called();
+      expect(stateRepositoryMock.fetchIdentity).to.not.be.called();
+
+      expect(fetchAssetLockTransactionOutputMock).to.not.be.called();
+    }
+  });
+});