@dashevo/wasm-dpp 0.23.0-dev.10

package/test/integration/document/validation/validateDocumentFactory.spec.js

@@ -0,0 +1,447 @@
+const { getRE2Class } = require('@dashevo/wasm-re2');
+
+const createAjv = require('../../../../lib/ajv/createAjv');
+
+const JsonSchemaValidator = require('../../../../lib/validation/JsonSchemaValidator');
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+
+const DataContract = require('../../../../lib/dataContract/DataContract');
+
+const validateDocumentFactory = require('../../../../lib/document/validation/validateDocumentFactory');
+const enrichDataContractWithBaseSchema = require('../../../../lib/dataContract/enrichDataContractWithBaseSchema');
+
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../lib/test/fixtures/getDocumentsFixture');
+
+const MissingDocumentTypeError = require('../../../../lib/errors/consensus/basic/document/MissingDocumentTypeError');
+const InvalidDocumentTypeError = require('../../../../lib/errors/consensus/basic/document/InvalidDocumentTypeError');
+
+const {
+  expectValidationError,
+  expectJsonSchemaError,
+} = require('../../../../lib/test/expect/expectError');
+const SomeConsensusError = require('../../../../lib/test/mocks/SomeConsensusError');
+
+describe('validateDocumentFactory', () => {
+  let dataContract;
+  let rawDocuments;
+  let rawDocument;
+  let documents;
+  let validateDocument;
+  let validator;
+  let validateProtocolVersionMock;
+
+  beforeEach(async function beforeEach() {
+    const RE2 = await getRE2Class();
+    const ajv = createAjv(RE2);
+
+    validator = new JsonSchemaValidator(ajv);
+
+    this.sinonSandbox.spy(validator, 'validate');
+
+    dataContract = getDataContractFixture();
+
+    validateProtocolVersionMock = this.sinonSandbox.stub().returns(new ValidationResult());
+
+    validateDocument = validateDocumentFactory(
+      validator,
+      enrichDataContractWithBaseSchema,
+      validateProtocolVersionMock,
+    );
+
+    documents = getDocumentsFixture(dataContract);
+    rawDocuments = documents.map((o) => o.toObject());
+    [rawDocument] = rawDocuments;
+  });
+
+  describe('Base schema', () => {
+    describe('$protocolVersion', () => {
+      it('should be present', () => {
+        delete rawDocument.$protocolVersion;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('');
+        expect(error.getKeyword()).to.equal('required');
+        expect(error.getParams().missingProperty).to.equal('$protocolVersion');
+      });
+
+      it('should be an integer', () => {
+        rawDocument.$protocolVersion = '1';
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$protocolVersion');
+        expect(error.getKeyword()).to.equal('type');
+      });
+
+      it('should be valid', async () => {
+        rawDocument.$protocolVersion = -1;
+
+        const protocolVersionError = new SomeConsensusError('test');
+        const protocolVersionResult = new ValidationResult([
+          protocolVersionError,
+        ]);
+
+        validateProtocolVersionMock.returns(protocolVersionResult);
+
+        const result = await validateDocument(rawDocument, dataContract);
+
+        expectValidationError(result, SomeConsensusError);
+
+        const [error] = result.getErrors();
+
+        expect(error).to.equal(protocolVersionError);
+
+        expect(validateProtocolVersionMock).to.be.calledOnceWith(
+          rawDocument.$protocolVersion,
+        );
+      });
+    });
+
+    describe('$id', () => {
+      it('should be present', () => {
+        delete rawDocument.$id;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('');
+        expect(error.getKeyword()).to.equal('required');
+        expect(error.getParams().missingProperty).to.equal('$id');
+      });
+
+      it('should be a byte array', () => {
+        rawDocument.$id = new Array(32).fill('string');
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result, 2);
+
+        const [error, byteArrayError] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$id/0');
+        expect(error.getKeyword()).to.equal('type');
+
+        expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      });
+
+      it('should be no less than 32 bytes', () => {
+        rawDocument.$id = Buffer.alloc(31);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$id');
+        expect(error.getKeyword()).to.equal('minItems');
+      });
+
+      it('should be no longer than 32 bytes', () => {
+        rawDocument.$id = Buffer.alloc(33);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$id');
+        expect(error.getKeyword()).to.equal('maxItems');
+      });
+    });
+
+    describe('$type', () => {
+      let DataContractMock;
+
+      afterEach(() => {
+        if (DataContractMock) {
+          DataContractMock.restore();
+        }
+      });
+
+      it('should be present', () => {
+        delete rawDocument.$type;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectValidationError(
+          result,
+          MissingDocumentTypeError,
+        );
+
+        const [error] = result.getErrors();
+
+        expect(error.getCode()).to.equal(1028);
+      });
+
+      it('should be defined in Data Contract', () => {
+        rawDocument.$type = 'undefinedDocument';
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectValidationError(
+          result,
+          InvalidDocumentTypeError,
+        );
+
+        const [error] = result.getErrors();
+
+        expect(error.getCode()).to.equal(1024);
+        expect(error.getType()).to.equal('undefinedDocument');
+      });
+
+      it('should throw an error if getDocumentSchemaRef throws error', function it() {
+        const someError = new Error();
+
+        DataContractMock = this.sinonSandbox.stub(DataContract.prototype, 'getDocumentSchemaRef').throws(someError);
+
+        let error;
+        try {
+          validateDocument(rawDocument, dataContract);
+        } catch (e) {
+          error = e;
+        }
+
+        expect(error).to.equal(someError);
+
+        expect(dataContract.getDocumentSchemaRef).to.have.been.calledOnce();
+      });
+    });
+
+    describe('$revision', () => {
+      it('should be present', () => {
+        delete rawDocument.$revision;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('');
+        expect(error.getKeyword()).to.equal('required');
+        expect(error.getParams().missingProperty).to.equal('$revision');
+      });
+
+      it('should be a number', () => {
+        rawDocument.$revision = 'string';
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$revision');
+        expect(error.getKeyword()).to.equal('type');
+      });
+
+      it('should be an integer', () => {
+        rawDocument.$revision = 1.1;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$revision');
+        expect(error.getKeyword()).to.equal('type');
+      });
+
+      it('should be greater or equal to one', () => {
+        rawDocument.$revision = -1;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$revision');
+        expect(error.getKeyword()).to.equal('minimum');
+      });
+    });
+
+    describe('$dataContractId', () => {
+      it('should be present', () => {
+        delete rawDocument.$dataContractId;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('');
+        expect(error.getKeyword()).to.equal('required');
+        expect(error.getParams().missingProperty).to.equal('$dataContractId');
+      });
+
+      it('should be a byte array', () => {
+        rawDocument.$dataContractId = new Array(32).fill('string');
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result, 2);
+
+        const [error, byteArrayError] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$dataContractId/0');
+        expect(error.getKeyword()).to.equal('type');
+
+        expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      });
+
+      it('should be no less than 32 bytes', () => {
+        rawDocument.$dataContractId = Buffer.alloc(31);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$dataContractId');
+        expect(error.getKeyword()).to.equal('minItems');
+      });
+
+      it('should be no longer than 32 bytes', () => {
+        rawDocument.$dataContractId = Buffer.alloc(33);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('/$dataContractId');
+        expect(error.getKeyword()).to.equal('maxItems');
+      });
+    });
+
+    describe('$ownerId', () => {
+      it('should be present', () => {
+        delete rawDocument.$ownerId;
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.getInstancePath()).to.equal('');
+        expect(error.getKeyword()).to.equal('required');
+        expect(error.getParams().missingProperty).to.equal('$ownerId');
+      });
+
+      it('should be a byte array', () => {
+        rawDocument.$ownerId = new Array(32).fill('string');
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result, 2);
+
+        const [error, byteArrayError] = result.getErrors();
+
+        expect(error.instancePath).to.equal('/$ownerId/0');
+        expect(error.getKeyword()).to.equal('type');
+
+        expect(byteArrayError.getKeyword()).to.equal('byteArray');
+      });
+
+      it('should be no less than 32 bytes', () => {
+        rawDocument.$ownerId = Buffer.alloc(31);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.instancePath).to.equal('/$ownerId');
+        expect(error.getKeyword()).to.equal('minItems');
+      });
+
+      it('should be no longer than 32 bytes', () => {
+        rawDocument.$ownerId = Buffer.alloc(33);
+
+        const result = validateDocument(rawDocument, dataContract);
+
+        expectJsonSchemaError(result);
+
+        const [error] = result.getErrors();
+
+        expect(error.instancePath).to.equal('/$ownerId');
+        expect(error.getKeyword()).to.equal('maxItems');
+      });
+    });
+  });
+
+  describe('Data Contract schema', () => {
+    it('should return an error if the first document is not valid against Data Contract', () => {
+      rawDocument.name = 1;
+
+      const result = validateDocument(rawDocument, dataContract);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.instancePath).to.equal('/name');
+      expect(error.getKeyword()).to.equal('type');
+    });
+
+    it('should return an error if the second document is not valid against Data Contract', () => {
+      // eslint-disable-next-line prefer-destructuring
+      rawDocument = rawDocuments[1];
+      rawDocument.undefined = 1;
+
+      const result = validateDocument(rawDocument, dataContract);
+
+      expectJsonSchemaError(result);
+
+      const [error] = result.getErrors();
+
+      expect(error.instancePath).to.equal('');
+      expect(error.getKeyword()).to.equal('additionalProperties');
+    });
+  });
+
+  it('return invalid result if a byte array exceeds `maxItems`', () => {
+    // eslint-disable-next-line prefer-destructuring
+    rawDocument = getDocumentsFixture(dataContract)[8].toObject();
+
+    rawDocument.byteArrayField = Buffer.alloc(32);
+
+    const result = validateDocument(rawDocument, dataContract);
+
+    expectJsonSchemaError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error.instancePath).to.equal('/byteArrayField');
+    expect(error.getKeyword()).to.equal('maxItems');
+  });
+
+  it('should return valid result is a document is valid', () => {
+    const result = validateDocument(rawDocument, dataContract);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+});

package/test/integration/error/consensus/createConsensusError.spec.js

@@ -0,0 +1,21 @@
+const InvalidDataContractIdError = require('../../../../lib/errors/consensus/basic/dataContract/InvalidDataContractIdError');
+const generateRandomIdentifier = require('../../../../lib/test/utils/generateRandomIdentifier');
+const createConsensusError = require('../../../../lib/errors/consensus/createConsensusError');
+
+describe('createConsensusError', () => {
+  it('should create an error instance from code and arguments', () => {
+    const expectedId = generateRandomIdentifier();
+    const invalidId = Buffer.alloc(16).fill(1);
+
+    const error = new InvalidDataContractIdError(expectedId.toBuffer(), invalidId);
+
+    const restoredError = createConsensusError(error.getCode(), error.getConstructorArguments());
+
+    // Stack will be always different so we need to skip it for comparison
+    expect(restoredError.message).to.equal(error.message);
+    expect(restoredError.getExpectedId()).to.deep.equal(error.getExpectedId());
+    expect(restoredError.getInvalidId()).to.deep.equal(error.getInvalidId());
+    expect(restoredError.getConstructorArguments()).to.deep.equal(error.getConstructorArguments());
+    expect(restoredError.getCode()).to.deep.equal(error.getCode());
+  });
+});

package/test/integration/identity/IdentityFacade.spec.js

@@ -0,0 +1,187 @@
+const { PublicKey } = require('@dashevo/dashcore-lib');
+const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
+
+const Identity = require('../../../lib/identity/Identity');
+const IdentityCreateTransition = require('../../../lib/identity/stateTransition/IdentityCreateTransition/IdentityCreateTransition');
+const IdentityTopUpTransition = require('../../../lib/identity/stateTransition/IdentityTopUpTransition/IdentityTopUpTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const getIdentityFixture = require('../../../lib/test/fixtures/getIdentityFixture');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+const InstantAssetLockProof = require('../../../lib/identity/stateTransition/assetLockProof/instant/InstantAssetLockProof');
+const getInstantAssetLockProofFixture = require('../../../lib/test/fixtures/getInstantAssetLockProofFixture');
+const getChainAssetLockProofFixture = require('../../../lib/test/fixtures/getChainAssetLockProofFixture');
+const ChainAssetLockProof = require('../../../lib/identity/stateTransition/assetLockProof/chain/ChainAssetLockProof');
+const IdentityUpdateTransition = require('../../../lib/identity/stateTransition/IdentityUpdateTransition/IdentityUpdateTransition');
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+
+describe('IdentityFacade', () => {
+  let dpp;
+  let identity;
+  let stateRepositoryMock;
+  let instantAssetLockProof;
+  let chainAssetLockProof;
+
+  beforeEach(async function beforeEach() {
+    const rawTransaction = '030000000137feb5676d0851337ea3c9a992496aab7a0b3eee60aeeb9774000b7f4bababa5000000006b483045022100d91557de37645c641b948c6cd03b4ae3791a63a650db3e2fee1dcf5185d1b10402200e8bd410bf516ca61715867666d31e44495428ce5c1090bf2294a829ebcfa4ef0121025c3cc7fbfc52f710c941497fd01876c189171ea227458f501afcb38a297d65b4ffffffff021027000000000000166a14152073ca2300a86b510fa2f123d3ea7da3af68dcf77cb0090a0000001976a914152073ca2300a86b510fa2f123d3ea7da3af68dc88ac00000000';
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchTransaction.resolves(rawTransaction);
+
+    dpp = new DashPlatformProtocol({
+      stateRepository: stateRepositoryMock,
+    });
+    await dpp.initialize();
+
+    chainAssetLockProof = getChainAssetLockProofFixture();
+    instantAssetLockProof = getInstantAssetLockProofFixture();
+    identity = getIdentityFixture();
+    identity.id = instantAssetLockProof.createIdentifier();
+    identity.setAssetLockProof(instantAssetLockProof);
+    identity.setBalance(0);
+  });
+
+  describe('#create', () => {
+    it('should create Identity', () => {
+      const publicKeys = identity.getPublicKeys()
+        .map((identityPublicKey) => ({
+          ...identityPublicKey.toObject(),
+          key: new PublicKey(identityPublicKey.getData()),
+        }));
+
+      const result = dpp.identity.create(
+        instantAssetLockProof,
+        publicKeys,
+      );
+
+      expect(result).to.be.an.instanceOf(Identity);
+      expect(result.toObject()).to.deep.equal(identity.toObject());
+    });
+  });
+
+  describe('#createFromObject', () => {
+    it('should create Identity from plain object', () => {
+      const result = dpp.identity.createFromObject(identity.toObject());
+
+      expect(result).to.be.an.instanceOf(Identity);
+
+      expect(result.toObject()).to.deep.equal(identity.toObject());
+    });
+  });
+
+  describe('#createFromBuffer', () => {
+    it('should create Identity from string', () => {
+      const result = dpp.identity.createFromBuffer(identity.toBuffer());
+
+      expect(result).to.be.an.instanceOf(Identity);
+
+      expect(result.toObject()).to.deep.equal(identity.toObject());
+    });
+  });
+
+  describe('#validate', () => {
+    it('should validate Identity', async () => {
+      const result = await dpp.identity.validate(identity);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  describe('#createInstantAssetLockProof', () => {
+    it('should create instant asset lock proof', () => {
+      const instantLock = instantAssetLockProof.getInstantLock();
+      const assetLockTransaction = instantAssetLockProof.getTransaction();
+      const outputIndex = instantAssetLockProof.getOutputIndex();
+
+      const result = dpp.identity.createInstantAssetLockProof(
+        instantLock,
+        assetLockTransaction,
+        outputIndex,
+      );
+
+      expect(result).to.be.instanceOf(InstantAssetLockProof);
+      expect(result.getInstantLock()).to.deep.equal(instantLock);
+      expect(result.getTransaction().toObject()).to.deep.equal(assetLockTransaction.toObject());
+      expect(result.getOutputIndex()).to.equal(outputIndex);
+    });
+  });
+
+  describe('#createChainAssetLockProof', () => {
+    it('should create chain asset lock proof', () => {
+      const coreChainLockedHeight = chainAssetLockProof.getCoreChainLockedHeight();
+      const outPoint = chainAssetLockProof.getOutPoint();
+
+      const result = dpp.identity.createChainAssetLockProof(
+        coreChainLockedHeight,
+        outPoint,
+      );
+
+      expect(result).to.be.instanceOf(ChainAssetLockProof);
+      expect(result.getCoreChainLockedHeight()).to.equal(coreChainLockedHeight);
+      expect(result.getOutPoint()).to.deep.equal(outPoint);
+    });
+  });
+
+  describe('#createIdentityCreateTransition', () => {
+    it('should create IdentityCreateTransition from Identity model', () => {
+      const stateTransition = dpp.identity.createIdentityCreateTransition(identity);
+
+      expect(stateTransition).to.be.instanceOf(IdentityCreateTransition);
+      expect(stateTransition.getPublicKeys()).to.deep.equal(identity.getPublicKeys());
+      expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
+        instantAssetLockProof.toObject(),
+      );
+    });
+  });
+
+  describe('#createIdentityTopUpTransition', () => {
+    it('should create IdentityTopUpTransition from identity id and outpoint', () => {
+      const stateTransition = dpp.identity
+        .createIdentityTopUpTransition(
+          identity.getId(),
+          instantAssetLockProof,
+        );
+
+      expect(stateTransition).to.be.instanceOf(IdentityTopUpTransition);
+      expect(stateTransition.getIdentityId()).to.be.deep.equal(identity.getId());
+      expect(stateTransition.getAssetLockProof().toObject()).to.deep.equal(
+        instantAssetLockProof.toObject(),
+      );
+    });
+  });
+
+  describe('#createIdentityUpdateTransition', () => {
+    it('should create IdentityUpdateTransition from identity id and public keys', () => {
+      const publicKeys = {
+        add: [new IdentityPublicKey({
+          id: 3,
+          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          data: Buffer.from('AuryIuMtRrl/VviQuyLD1l4nmxi9ogPzC9LT7tdpo0di', 'base64'),
+          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+          securityLevel: IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+          readOnly: false,
+        })],
+      };
+
+      const stateTransition = dpp.identity
+        .createIdentityUpdateTransition(
+          identity,
+          publicKeys,
+        );
+
+      expect(stateTransition).to.be.instanceOf(IdentityUpdateTransition);
+      expect(stateTransition.getIdentityId()).to.be.deep.equal(identity.getId());
+      expect(stateTransition.getRevision()).to.equal(
+        identity.getRevision() + 1,
+      );
+      expect(
+        stateTransition.getPublicKeysToAdd().map((pk) => pk.toObject()),
+      ).to.deep.equal(publicKeys.add);
+      expect(stateTransition.getPublicKeyIdsToDisable()).to.equal(undefined);
+      expect(stateTransition.getPublicKeysDisabledAt()).to.equal(undefined);
+    });
+  });
+});