@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/dataTrigger/featureFlagDataTriggers/createFeatureFlagDataTrigger.spec.js

@@ -0,0 +1,101 @@
+const Long = require('long');
+
+const createFeatureFlagDataTrigger = require('../../../../lib/dataTrigger/featureFlagsDataTriggers/createFeatureFlagDataTrigger');
+
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+const getFeatureFlagsDocumentsFixture = require('../../../../lib/test/fixtures/getFeatureFlagsDocumentsFixture');
+const getDocumentTransitionsFixture = require('../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+const DataTriggerExecutionResult = require('../../../../lib/dataTrigger/DataTriggerExecutionResult');
+const DataTriggerConditionError = require('../../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerConditionError');
+const Identifier = require('../../../../lib/identifier/Identifier');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('createFeatureFlagDataTrigger', () => {
+  let contextMock;
+  let stateRepositoryMock;
+  let documentTransition;
+  let topLevelIdentityId;
+
+  beforeEach(function beforeEach() {
+    topLevelIdentityId = getIdentityFixture().getId();
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchLatestPlatformBlockHeader.resolves({
+      height: new Long(42),
+    });
+
+    const [document] = getFeatureFlagsDocumentsFixture();
+
+    [documentTransition] = getDocumentTransitionsFixture({
+      create: [document],
+    });
+
+    const context = new StateTransitionExecutionContext();
+
+    contextMock = {
+      getStateRepository: () => stateRepositoryMock,
+      getOwnerId: this.sinonSandbox.stub(),
+      getDataContract: () => getFeatureFlagsDocumentsFixture.dataContract,
+      getStateTransitionExecutionContext: () => context,
+    };
+    contextMock.getOwnerId.returns(topLevelIdentityId);
+  });
+
+  it('should return an error if height is lower than block height', async () => {
+    documentTransition.data.enableAtHeight = 1;
+
+    const result = await createFeatureFlagDataTrigger(
+      documentTransition, contextMock, topLevelIdentityId,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal('Feature flag cannot be enabled in the past on block 1. Current block height is 42');
+  });
+
+  it('should return an error if owner id is not equal to top level identity id', async () => {
+    contextMock.getOwnerId.returns(Identifier.from(Buffer.alloc(32, 1)));
+
+    const result = await createFeatureFlagDataTrigger(
+      documentTransition, contextMock, topLevelIdentityId,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal('This identity can\'t activate selected feature flag');
+  });
+
+  it('should pass', async () => {
+    const result = await createFeatureFlagDataTrigger(
+      documentTransition, contextMock, topLevelIdentityId,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.true();
+  });
+
+  it('should pass on dry run', async () => {
+    contextMock.getStateTransitionExecutionContext().enableDryRun();
+
+    const result = await createFeatureFlagDataTrigger(
+      documentTransition, contextMock, topLevelIdentityId,
+    );
+
+    contextMock.getStateTransitionExecutionContext().disableDryRun();
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.true();
+
+    expect(contextMock.getOwnerId).to.not.be.called();
+    expect(stateRepositoryMock.fetchLatestPlatformBlockHeader).to.not.be.called();
+  });
+});

package/test/unit/dataTrigger/getDataTriggersFactory.spec.js

@@ -0,0 +1,113 @@
+const {
+  contractId: dpnsContractId,
+  ownerId: dpnsOwnerId,
+} = require('@dashevo/dpns-contract/lib/systemIds');
+
+const AbstractDocumentTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/documentTransition/AbstractDocumentTransition');
+
+const getDataTriggersFactory = require('../../../lib/dataTrigger/getDataTriggersFactory');
+
+const getDpnsDocumentFixture = require('../../../lib/test/fixtures/getDpnsDocumentFixture');
+
+const DataTrigger = require('../../../lib/dataTrigger/DataTrigger');
+
+const createDomainDataTrigger = require('../../../lib/dataTrigger/dpnsTriggers/createDomainDataTrigger');
+const rejectDataTrigger = require('../../../lib/dataTrigger/rejectDataTrigger');
+const Identifier = require('../../../lib/identifier/Identifier');
+
+describe('getDataTriggers', () => {
+  let getDataTriggers;
+
+  let createDocument;
+  let updateDocument;
+  let deleteDocument;
+
+  let createTrigger;
+  let updateTrigger;
+  let deleteTrigger;
+
+  let updatePreorderTrigger;
+  let deletePreorderTrigger;
+
+  let dataContractId;
+  let topLevelIdentity;
+
+  let processMock;
+
+  beforeEach(function beforeEach() {
+    createDocument = getDpnsDocumentFixture.getChildDocumentFixture();
+    updateDocument = getDpnsDocumentFixture.getChildDocumentFixture();
+    deleteDocument = getDpnsDocumentFixture.getChildDocumentFixture();
+    deleteDocument.data = {};
+
+    dataContractId = Identifier.from(dpnsContractId);
+    topLevelIdentity = Identifier.from(dpnsOwnerId);
+
+    createTrigger = new DataTrigger(
+      dataContractId, 'domain', AbstractDocumentTransition.ACTIONS.CREATE, createDomainDataTrigger, topLevelIdentity,
+    );
+    updateTrigger = new DataTrigger(
+      dataContractId, 'domain', AbstractDocumentTransition.ACTIONS.REPLACE, rejectDataTrigger,
+    );
+    deleteTrigger = new DataTrigger(
+      dataContractId, 'domain', AbstractDocumentTransition.ACTIONS.DELETE, rejectDataTrigger,
+    );
+    updatePreorderTrigger = new DataTrigger(
+      dataContractId, 'preorder', AbstractDocumentTransition.ACTIONS.REPLACE, rejectDataTrigger,
+    );
+    deletePreorderTrigger = new DataTrigger(
+      dataContractId, 'preorder', AbstractDocumentTransition.ACTIONS.DELETE, rejectDataTrigger,
+    );
+
+    processMock = this.sinonSandbox.stub(process, 'env').value({
+      DPNS_CONTRACT_ID: dataContractId,
+      DPNS_TOP_LEVEL_IDENTITY: topLevelIdentity,
+    });
+
+    getDataTriggers = getDataTriggersFactory();
+  });
+
+  afterEach(() => {
+    processMock.restore();
+  });
+
+  it('should return matching triggers', () => {
+    let result = getDataTriggers(
+      dataContractId, createDocument.getType(), AbstractDocumentTransition.ACTIONS.CREATE,
+    );
+
+    expect(result).to.deep.equal([createTrigger]);
+
+    result = getDataTriggers(
+      dataContractId, updateDocument.getType(), AbstractDocumentTransition.ACTIONS.REPLACE,
+    );
+
+    expect(result).to.deep.equal([updateTrigger]);
+
+    result = getDataTriggers(
+      dataContractId, deleteDocument.getType(), AbstractDocumentTransition.ACTIONS.DELETE,
+    );
+
+    expect(result).to.deep.equal([deleteTrigger]);
+
+    result = getDataTriggers(
+      dataContractId, 'preorder', AbstractDocumentTransition.ACTIONS.REPLACE,
+    );
+
+    expect(result).to.deep.equal([updatePreorderTrigger]);
+
+    result = getDataTriggers(
+      dataContractId, 'preorder', AbstractDocumentTransition.ACTIONS.DELETE,
+    );
+
+    expect(result).to.deep.equal([deletePreorderTrigger]);
+  });
+
+  it('should return empty trigger array for any other type except `domain`', () => {
+    const result = getDataTriggers(
+      dataContractId, 'otherType', AbstractDocumentTransition.ACTIONS.CREATE,
+    );
+
+    expect(result).to.deep.equal([]);
+  });
+});

package/test/unit/dataTrigger/rejectDataTrigger.spec.js

@@ -0,0 +1,51 @@
+const bs58 = require('bs58');
+const rejectDataTrigger = require('../../../lib/dataTrigger/rejectDataTrigger');
+
+const DataTriggerExecutionContext = require('../../../lib/dataTrigger/DataTriggerExecutionContext');
+
+const { getChildDocumentFixture } = require('../../../lib/test/fixtures/getDpnsDocumentFixture');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+
+const getDpnsContractFixture = require('../../../lib/test/fixtures/getDpnsContractFixture');
+const getDocumentTransitionFixture = require('../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const DataTriggerExecutionResult = require('../../../lib/dataTrigger/DataTriggerExecutionResult');
+const StateTransitionExecutionContext = require('../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('rejectDataTrigger', () => {
+  let documentTransition;
+  let context;
+  let stateRepositoryMock;
+  let dataContract;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDpnsContractFixture();
+    const document = getChildDocumentFixture();
+
+    [documentTransition] = getDocumentTransitionFixture({
+      create: [],
+      delete: [document],
+    });
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    context = new DataTriggerExecutionContext(
+      stateRepositoryMock,
+      bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq'),
+      dataContract,
+      new StateTransitionExecutionContext(),
+    );
+  });
+
+  it('should always fail', async () => {
+    const result = await rejectDataTrigger(documentTransition, context);
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error.message).to.equal('Action is not allowed');
+  });
+});

package/test/unit/dataTrigger/rewardShareDataTriggers/createMasternodeRewardSharesDataTrigger.spec.js

@@ -0,0 +1,200 @@
+const SimplifiedMNListEntry = require('@dashevo/dashcore-lib/lib/deterministicmnlist/SimplifiedMNListEntry');
+const getIdentityFixture = require('../../../../lib/test/fixtures/getIdentityFixture');
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+const getMasternodeRewardShareDocumentsFixture = require('../../../../lib/test/fixtures/getMasternodeRewardShareDocumentsFixture');
+const getMasternodeRewardSharesContractFixture = require('../../../../lib/test/fixtures/getMasternodeRewardSharesContractFixture');
+const getDocumentTransitionsFixture = require('../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+const createRewardShareDataTrigger = require('../../../../lib/dataTrigger/rewardShareDataTriggers/createMasternodeRewardSharesDataTrigger');
+const DataTriggerExecutionResult = require('../../../../lib/dataTrigger/DataTriggerExecutionResult');
+const DataTriggerConditionError = require('../../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerConditionError');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('createMasternodeRewardSharesDataTrigger', () => {
+  let contextMock;
+  let stateRepositoryMock;
+  let documentTransition;
+  let topLevelIdentityId;
+  let smlStoreMock;
+  let smlMock;
+  let documentsFixture;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    topLevelIdentityId = Buffer.from('c286807d463b06c7aba3b9a60acf64c1fc03da8c1422005cd9b4293f08cf0562', 'hex');
+
+    smlMock = {
+      getQuorum: this.sinonSandbox.stub(),
+      toSimplifiedMNListDiff: this.sinonSandbox.stub(),
+      getQuorumsOfType: this.sinonSandbox.stub(),
+      getValidMasternodesList: this.sinonSandbox.stub().returns([
+        new SimplifiedMNListEntry({
+          proRegTxHash: 'c286807d463b06c7aba3b9a60acf64c1fc03da8c1422005cd9b4293f08cf0562',
+          confirmedHash: '4eb56228c535db3b234907113fd41d57bcc7cdcb8e0e00e57590af27ee88c119',
+          service: '192.168.65.2:20101',
+          pubKeyOperator: '809519c5f6f3be1c08782ac42ae9a83b6c7205eba43f9a96a4f032ec7a73f1a7c25fa78cce0d6d9c135f7e2c28527179',
+          votingAddress: 'yXmprXYP51uzfMyndtWwxz96MnkCKkFc9x',
+          isValid: true,
+        }),
+        new SimplifiedMNListEntry({
+          proRegTxHash: 'a3e1edc6bd352eeaf0ae58e30781ef4b127854241a3fe7fddf36d5b7e1dc2b3f',
+          confirmedHash: '27a0b637b56af038c45e2fd1f06c2401c8dadfa28ca5e0d19ca836cc984a8378',
+          service: '192.168.65.2:20201',
+          pubKeyOperator: '987a4873caba62cd45a2f7d4aa6d94519ee6753e9bef777c927cb94ade768a542b0ff34a93231d3a92b4e75ffdaa366e',
+          votingAddress: 'ycL7L4mhYoaZdm9TH85svvpfeKtdfo249u',
+          isValid: true,
+        }),
+      ]),
+    };
+
+    const dataContract = getMasternodeRewardSharesContractFixture();
+
+    documentsFixture = getMasternodeRewardShareDocumentsFixture(undefined, undefined, dataContract);
+
+    smlStoreMock = {
+      getSMLbyHeight: this.sinonSandbox.stub().returns(smlMock),
+      getCurrentSML: this.sinonSandbox.stub().returns(smlMock),
+    };
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchSMLStore.resolves(smlStoreMock);
+    stateRepositoryMock.fetchIdentity.resolves(getIdentityFixture());
+    stateRepositoryMock.fetchDocuments.resolves([]);
+
+    const [document] = getMasternodeRewardShareDocumentsFixture(undefined, undefined, dataContract);
+
+    [documentTransition] = getDocumentTransitionsFixture({
+      create: [document],
+    });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    contextMock = {
+      getStateRepository: () => stateRepositoryMock,
+      getOwnerId: this.sinonSandbox.stub(),
+      getDataContract: () => dataContract,
+      getStateTransitionExecutionContext: () => executionContext,
+    };
+    contextMock.getOwnerId.returns(topLevelIdentityId);
+  });
+
+  it('should return an error if percentage > 10000', async () => {
+    stateRepositoryMock.fetchDocuments.resolves(documentsFixture);
+    // documentsFixture contains percentage = 500
+    documentTransition.data.percentage = 9501;
+
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal('Percentage can not be more than 10000');
+
+    expect(stateRepositoryMock.fetchSMLStore).to.be.calledOnce();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      documentTransition.data.payToId,
+      executionContext,
+    );
+  });
+
+  it('should return an error if payToId does not exist', async () => {
+    stateRepositoryMock.fetchIdentity.resolves(null);
+
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal(`Identity ${documentTransition.data.payToId} doesn't exist`);
+
+    expect(stateRepositoryMock.fetchSMLStore).to.be.calledOnce();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      documentTransition.data.payToId,
+      executionContext,
+    );
+  });
+
+  it('should return an error if ownerId is not a masternode identity', async () => {
+    contextMock.getOwnerId.returns(getIdentityFixture().getId());
+
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal('Only masternode identities can share rewards');
+
+    expect(stateRepositoryMock.fetchSMLStore).to.be.calledOnce();
+    expect(stateRepositoryMock.fetchIdentity).to.be.not.called();
+  });
+
+  it('should pass', async () => {
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.true();
+
+    expect(stateRepositoryMock.fetchSMLStore).to.be.calledOnce();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      documentTransition.data.payToId,
+      executionContext,
+    );
+  });
+
+  it('should pass on dry run', async () => {
+    stateRepositoryMock.fetchIdentity.resolves(null);
+
+    executionContext.enableDryRun();
+
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+    executionContext.disableDryRun();
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.true();
+    expect(stateRepositoryMock.fetchSMLStore).to.not.be.called();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      documentTransition.data.payToId,
+      executionContext,
+    );
+  });
+
+  it('should return an error if there are 16 stored shares', async () => {
+    stateRepositoryMock.fetchDocuments.resolves(new Array(16).fill(0));
+
+    const result = await createRewardShareDataTrigger(
+      documentTransition, contextMock,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.false();
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataTriggerConditionError);
+    expect(error.message).to.equal('Reward shares cannot contain more than 16 identities');
+
+    expect(stateRepositoryMock.fetchSMLStore).to.be.calledOnce();
+    expect(stateRepositoryMock.fetchIdentity).to.be.calledOnceWithExactly(
+      documentTransition.data.payToId,
+      executionContext,
+    );
+  });
+});

package/test/unit/decodeProtocolEntityFactory.spec.js

@@ -0,0 +1,75 @@
+const decodeProtocolEntityFactory = require('../../lib/decodeProtocolEntityFactory');
+const ProtocolVersionParsingError = require('../../lib/errors/consensus/basic/decode/ProtocolVersionParsingError');
+const SerializedObjectParsingError = require('../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+
+const { encode } = require('../../lib/util/serializer');
+
+describe('decodeProtocolEntityFactory', () => {
+  let decodeProtocolEntity;
+  let versionCompatibilityMap;
+  let parsedProtocolVersion;
+  let entityBuffer;
+  let protocolVersionBuffer;
+  let rawEntity;
+  let buffer;
+
+  beforeEach(() => {
+    parsedProtocolVersion = 0;
+
+    protocolVersionBuffer = Buffer.alloc(4);
+    protocolVersionBuffer.writeUInt32LE(parsedProtocolVersion, 0);
+
+    rawEntity = { test: 'successful' };
+    entityBuffer = encode(rawEntity);
+
+    buffer = Buffer.concat([protocolVersionBuffer, entityBuffer]);
+
+    versionCompatibilityMap = {
+      0: 0,
+      1: 0,
+    };
+
+    decodeProtocolEntity = decodeProtocolEntityFactory(
+      versionCompatibilityMap,
+    );
+  });
+
+  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.be.instanceOf(Error);
+      expect(e.getCode()).to.equal(1000);
+    }
+  });
+
+  it('should throw SerializedObjectParsingError if entity decoding fails', () => {
+    entityBuffer = Buffer.alloc(5).fill(1);
+
+    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.be.an.instanceOf(Error);
+      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);
+  });
+});