@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,132 @@
+const bs58 = require('bs58');
+const AbstractDocumentTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/documentTransition/AbstractDocumentTransition');
+const DataTrigger = require('../../../lib/dataTrigger/DataTrigger');
+const DataTriggerExecutionContext = require('../../../lib/dataTrigger/DataTriggerExecutionContext');
+const getDpnsContractFixture = require('../../../lib/test/fixtures/getDpnsContractFixture');
+const DataTriggerExecutionResult = require('../../../lib/dataTrigger/DataTriggerExecutionResult');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const DataTriggerExecutionError = require('../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerExecutionError');
+const DataTriggerInvalidResultError = require('../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerInvalidResultError');
+
+describe('DataTrigger', () => {
+  let dataContractMock;
+  let context;
+  let triggerStub;
+  let document;
+  let topLevelIdentity;
+
+  beforeEach(function beforeEach() {
+    triggerStub = this.sinonSandbox.stub().resolves(new DataTriggerExecutionResult());
+    dataContractMock = getDpnsContractFixture();
+
+    ([document] = getDocumentsFixture());
+
+    context = new DataTriggerExecutionContext(
+      null,
+      bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq'),
+      dataContractMock,
+    );
+
+    topLevelIdentity = context.getOwnerId();
+  });
+
+  it('should check trigger fields', () => {
+    const trigger = new DataTrigger(
+      dataContractMock.getId(),
+      document.getType(),
+      AbstractDocumentTransition.ACTIONS.CREATE,
+      triggerStub,
+      topLevelIdentity,
+    );
+
+    expect(trigger.dataContractId).to.equal(dataContractMock.getId());
+    expect(trigger.documentType).to.equal(document.getType());
+    expect(trigger.transitionAction).to.equal(AbstractDocumentTransition.ACTIONS.CREATE);
+    expect(trigger.trigger).to.equal(triggerStub);
+    expect(trigger.topLevelIdentity).to.equal(topLevelIdentity);
+  });
+
+  describe('#execute', () => {
+    it('should check trigger execution', async () => {
+      const trigger = new DataTrigger(
+        dataContractMock.getId(),
+        document.getType(),
+        AbstractDocumentTransition.ACTIONS.CREATE,
+        triggerStub,
+        topLevelIdentity,
+      );
+
+      const result = await trigger.execute(context);
+
+      expect(result).to.be.instanceOf(DataTriggerExecutionResult);
+    });
+
+    it('should pass through the result of the trigger function', async () => {
+      const functionResult = new DataTriggerExecutionResult();
+
+      const triggerError = new Error('Trigger error');
+
+      functionResult.addError(triggerError);
+
+      triggerStub.resolves(functionResult);
+
+      const trigger = new DataTrigger(
+        dataContractMock.getId(),
+        document.getType(),
+        AbstractDocumentTransition.ACTIONS.CREATE,
+        triggerStub,
+        topLevelIdentity,
+      );
+
+      const result = await trigger.execute(document, context);
+
+      expect(result).to.deep.equal(functionResult);
+      expect(result.getErrors()[0]).to.deep.equal(triggerError);
+    });
+
+    it('should return a result with execution error if trigger function have thrown an error', async () => {
+      const triggerError = new Error('Trigger error');
+
+      triggerStub.throws(triggerError);
+
+      const trigger = new DataTrigger(
+        dataContractMock.getId(),
+        document.getType(),
+        AbstractDocumentTransition.ACTIONS.CREATE,
+        triggerStub,
+        topLevelIdentity,
+      );
+
+      const result = await trigger.execute(document, context);
+
+      expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+
+      const [error] = result.getErrors();
+
+      expect(error).to.be.an.instanceOf(DataTriggerExecutionError);
+
+      expect(error.getExecutionError()).to.equal(triggerError);
+    });
+
+    it('should return a result with invalid result error if trigger function have not returned any result', async () => {
+      triggerStub.resolves(null);
+
+      const trigger = new DataTrigger(
+        dataContractMock.getId(),
+        document.getType(),
+        AbstractDocumentTransition.ACTIONS.CREATE,
+        triggerStub,
+        topLevelIdentity,
+      );
+
+      const result = await trigger.execute(document, context);
+
+      expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+
+      const [error] = result.getErrors();
+
+      expect(error).to.be.an.instanceOf(DataTriggerInvalidResultError);
+      expect(error.message).to.equal('Data trigger have not returned any result');
+    });
+  });
+});

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

@@ -0,0 +1,29 @@
+const bs58 = require('bs58');
+const DataTriggerExecutionContext = require('../../../lib/dataTrigger/DataTriggerExecutionContext');
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+const getDpnsContractFixture = require('../../../lib/test/fixtures/getDpnsContractFixture');
+const StateTransitionExecutionContext = require('../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('DataTriggerExecutionContext', () => {
+  let dataContractMock;
+  let stateRepositoryMock;
+
+  beforeEach(function beforeEach() {
+    dataContractMock = getDpnsContractFixture();
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+  });
+
+  it('should have all getters working', () => {
+    const ownerId = bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq');
+    const context = new DataTriggerExecutionContext(
+      stateRepositoryMock,
+      ownerId,
+      dataContractMock,
+      new StateTransitionExecutionContext(),
+    );
+
+    expect(context.getDataContract()).to.be.deep.equal(dataContractMock);
+    expect(context.getStateRepository()).to.be.deep.equal(stateRepositoryMock);
+    expect(context.getOwnerId()).to.be.deep.equal(ownerId);
+  });
+});

package/test/unit/dataTrigger/dashpayDataTriggers/createContactRequestDataTrigger.spec.js

@@ -0,0 +1,109 @@
+const createContactRequestDataTrigger = require('../../../../lib/dataTrigger/dashpayDataTriggers/createContactRequestDataTrigger');
+
+const DataTriggerExecutionContext = require('../../../../lib/dataTrigger/DataTriggerExecutionContext');
+const DataTriggerExecutionResult = require('../../../../lib/dataTrigger/DataTriggerExecutionResult');
+const DataTriggerConditionError = require('../../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerConditionError');
+
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+const getDocumentTransitionFixture = require('../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const getDashPayContractFixture = require('../../../../lib/test/fixtures/getDashPayContractFixture');
+const { getContactRequestDocumentFixture } = require('../../../../lib/test/fixtures/getDashPayDocumentFixture');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('createContactRequestDataTrigger', () => {
+  let context;
+  let dashPayIdentity;
+  let stateRepositoryMock;
+  let dataContract;
+  let contactRequestDocument;
+  let documentTransition;
+
+  beforeEach(function beforeEach() {
+    contactRequestDocument = getContactRequestDocumentFixture();
+    dataContract = getDashPayContractFixture();
+
+    [documentTransition] = getDocumentTransitionFixture({
+      create: [contactRequestDocument],
+    });
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchLatestPlatformBlockHeader.resolves({
+      coreChainLockedHeight: 42,
+    });
+
+    context = new DataTriggerExecutionContext(
+      stateRepositoryMock,
+      contactRequestDocument.getOwnerId(),
+      dataContract,
+      new StateTransitionExecutionContext(),
+    );
+
+    dashPayIdentity = context.getOwnerId();
+  });
+
+  it('should successfully execute if document is valid', async () => {
+    contactRequestDocument.data.coreHeightCreatedAt = 40;
+
+    [documentTransition] = getDocumentTransitionFixture({
+      create: [contactRequestDocument],
+    });
+
+    const result = await createContactRequestDataTrigger(
+      documentTransition, context, dashPayIdentity,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(stateRepositoryMock.fetchLatestPlatformBlockHeader).to.be.calledOnce();
+    expect(result.isOk()).to.be.true();
+  });
+
+  it('should successfully execute if document has no `coreHeightCreatedAt` field', async () => {
+    const result = await createContactRequestDataTrigger(
+      documentTransition, context, dashPayIdentity,
+    );
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(stateRepositoryMock.fetchLatestPlatformBlockHeader).to.be.not.called();
+    expect(result.isOk()).to.be.true();
+  });
+
+  it('should fail with out of window error', async () => {
+    contactRequestDocument.data.coreHeightCreatedAt = 10;
+
+    [documentTransition] = getDocumentTransitionFixture({
+      create: [contactRequestDocument],
+    });
+
+    const result = await createContactRequestDataTrigger(
+      documentTransition, context, dashPayIdentity,
+    );
+
+    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('Core height 10 is out of block height window from 34 to 50');
+  });
+
+  it('should successfully execute on dry run', async () => {
+    contactRequestDocument.data.coreHeightCreatedAt = 10;
+    [documentTransition] = getDocumentTransitionFixture({
+      create: [contactRequestDocument],
+    });
+
+    context.getStateTransitionExecutionContext().enableDryRun();
+
+    const result = await createContactRequestDataTrigger(
+      documentTransition, context, dashPayIdentity,
+    );
+
+    context.getStateTransitionExecutionContext().disableDryRun();
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(stateRepositoryMock.fetchLatestPlatformBlockHeader).to.be.not.called();
+    expect(result.isOk()).to.be.true();
+  });
+});

package/test/unit/dataTrigger/dpnsTriggers/createDomainDataTrigger.spec.js

@@ -0,0 +1,382 @@
+const createDomainDataTrigger = require('../../../../lib/dataTrigger/dpnsTriggers/createDomainDataTrigger');
+
+const DataTriggerExecutionContext = require('../../../../lib/dataTrigger/DataTriggerExecutionContext');
+const DataTriggerExecutionResult = require('../../../../lib/dataTrigger/DataTriggerExecutionResult');
+
+const { getParentDocumentFixture, getChildDocumentFixture, getTopDocumentFixture } = require('../../../../lib/test/fixtures/getDpnsDocumentFixture');
+const getPreorderDocumentFixture = require('../../../../lib/test/fixtures/getPreorderDocumentFixture');
+const getDpnsContractFixture = require('../../../../lib/test/fixtures/getDpnsContractFixture');
+const getDocumentTransitionFixture = require('../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+const createStateRepositoryMock = require('../../../../lib/test/mocks/createStateRepositoryMock');
+
+const { hash } = require('../../../../lib/util/hash');
+
+const DataTriggerConditionError = require('../../../../lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerConditionError');
+const Identifier = require('../../../../lib/identifier/Identifier');
+const StateTransitionExecutionContext = require('../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('createDomainDataTrigger', () => {
+  let parentDocumentTransition;
+  let childDocumentTransition;
+  let childDocument;
+  let parentDocument;
+  let topDocument;
+  let context;
+  let stateRepositoryMock;
+  let dataContract;
+  let topLevelIdentity;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDpnsContractFixture();
+
+    topDocument = getTopDocumentFixture();
+    parentDocument = getParentDocumentFixture();
+    childDocument = getChildDocumentFixture();
+    const preorderDocument = getPreorderDocumentFixture();
+
+    [parentDocumentTransition] = getDocumentTransitionFixture({
+      create: [parentDocument],
+    });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const {
+      preorderSalt, records, normalizedParentDomainName, normalizedLabel,
+    } = childDocument.getData();
+
+    let fullDomainName = normalizedLabel;
+    if (normalizedParentDomainName.length > 0) {
+      fullDomainName = `${normalizedLabel}.${normalizedParentDomainName}`;
+    }
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDocuments.resolves([]);
+
+    const [normalizedParentLabel] = normalizedParentDomainName.split('.');
+    const normalizedGrandParentDomainName = normalizedParentDomainName.split('.')
+      .slice(1)
+      .join('.');
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        childDocument.getType(),
+        {
+          where: [
+            ['normalizedParentDomainName', '==', normalizedGrandParentDomainName],
+            ['normalizedLabel', '==', normalizedParentLabel],
+          ],
+        },
+      )
+      .resolves([parentDocument]);
+
+    const saltedDomainHashBuffer = Buffer.concat([
+      preorderSalt,
+      Buffer.from(fullDomainName),
+    ]);
+
+    const saltedDomainHash = hash(saltedDomainHashBuffer);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        'preorder',
+        { where: [['saltedDomainHash', '==', saltedDomainHash]] },
+      )
+      .resolves([preorderDocument.toObject()]);
+
+    stateRepositoryMock.fetchTransaction.resolves(null);
+
+    stateRepositoryMock.fetchTransaction
+      .withArgs(
+        records.dashUniqueIdentityId,
+      )
+      .resolves({ confirmations: 10 });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    context = new DataTriggerExecutionContext(
+      stateRepositoryMock,
+      records.dashUniqueIdentityId,
+      dataContract,
+      executionContext,
+    );
+
+    topLevelIdentity = context.getOwnerId();
+  });
+
+  it('should successfully execute if document is valid', async () => {
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    expect(result.isOk()).to.be.true();
+  });
+
+  it('should fail with invalid normalizedLabel', async () => {
+    childDocument = getChildDocumentFixture({ normalizedLabel: childDocument.getData().label });
+    stateRepositoryMock.fetchTransaction
+      .withArgs(
+        childDocument.getData().records.dashUniqueIdentityId,
+      )
+      .resolves({ confirmations: 10 });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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('Normalized label doesn\'t match label');
+  });
+
+  it('should fail with invalid parent domain', async () => {
+    childDocument = getChildDocumentFixture({
+      label: 'label',
+      normalizedLabel: 'label',
+      normalizedParentDomainName: 'parent.invalidname',
+    });
+
+    stateRepositoryMock.fetchTransaction
+      .withArgs(
+        childDocument.getData().records.dashUniqueIdentityId,
+      )
+      .resolves({ confirmations: 10 });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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('Parent domain is not present');
+
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledOnceWithExactly(
+      context.getDataContract().getId(),
+      'domain',
+      {
+        where: [
+          ['normalizedParentDomainName', '==', 'invalidname'],
+          ['normalizedLabel', '==', 'parent'],
+        ],
+      },
+      executionContext,
+    );
+  });
+
+  it('should fail with invalid dashUniqueIdentityId', async () => {
+    const dashUniqueIdentityId = Identifier.from(
+      Buffer.alloc(32, 5),
+    );
+
+    childDocument = getChildDocumentFixture({
+      records: {
+        dashUniqueIdentityId: dashUniqueIdentityId.toBuffer(),
+      },
+    });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(`ownerId ${childDocument.getOwnerId()} doesn't match dashUniqueIdentityId ${dashUniqueIdentityId}`);
+  });
+
+  it('should fail with invalid dashAliasIdentityId', async () => {
+    const dashUniqueIdentityId = Identifier.from(
+      Buffer.alloc(32, 2),
+    );
+
+    childDocument = getChildDocumentFixture({
+      records: {
+        dashAliasIdentityId: dashUniqueIdentityId.toBuffer(),
+      },
+    });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(`ownerId ${childDocument.getOwnerId()} doesn't match dashAliasIdentityId ${dashUniqueIdentityId}`);
+  });
+
+  it('should fail with preorder document was not found', async () => {
+    childDocument = getChildDocumentFixture({
+      preorderSalt: Buffer.alloc(256, '012fd'),
+    });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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('preorderDocument was not found');
+  });
+
+  it('should fail with invalid full domain name length', async () => {
+    childDocument = getChildDocumentFixture({
+      normalizedParentDomainName: 'a'.repeat(512),
+    });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(
+      'Full domain name length can not be more than 253 characters long but got 518',
+    );
+  });
+
+  it('should fail with identity can\'t create top level domain', async () => {
+    parentDocumentTransition.data.normalizedParentDomainName = '';
+
+    topLevelIdentity = Buffer.from('someIdentity');
+
+    const result = await createDomainDataTrigger(
+      parentDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(
+      'Can\'t create top level domain for this identity',
+    );
+  });
+
+  it('should fail with disallowed domain creation', async () => {
+    parentDocument.ownerId = Buffer.from('newId');
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(
+      'The subdomain can be created only by the parent domain owner',
+    );
+  });
+
+  it('should fail with allowing subdomains for non top level domain', async () => {
+    childDocument = getChildDocumentFixture({ subdomainRules: { allowSubdomains: true } });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    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(
+      'Allowing subdomains registration is forbidden for non top level domains',
+    );
+  });
+
+  it('should allow creating a second level domain by any identity', async () => {
+    topDocument.ownerId = 'anotherId';
+
+    stateRepositoryMock.fetchDocuments.resolves([topDocument]);
+
+    const result = await createDomainDataTrigger(
+      parentDocumentTransition, context, topLevelIdentity,
+    );
+
+    expect(result.isOk()).to.be.true();
+  });
+
+  it('should return DataTriggerExecutionResult om dry run', async () => {
+    context.getStateTransitionExecutionContext().enableDryRun();
+
+    childDocument = getChildDocumentFixture({ normalizedLabel: childDocument.getData().label });
+    stateRepositoryMock.fetchTransaction
+      .withArgs(
+        childDocument.getData().records.dashUniqueIdentityId,
+      )
+      .resolves({ confirmations: 10 });
+
+    [childDocumentTransition] = getDocumentTransitionFixture({
+      create: [childDocument],
+    });
+
+    const result = await createDomainDataTrigger(
+      childDocumentTransition, context, topLevelIdentity,
+    );
+
+    context.getStateTransitionExecutionContext().disableDryRun();
+
+    expect(result).to.be.an.instanceOf(DataTriggerExecutionResult);
+    expect(result.isOk()).to.be.true();
+  });
+});