@dashevo/wasm-dpp 0.23.0-dev.10

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@dashevo/wasm-dpp",
+  "version": "0.23.0-dev.10",
+  "description": "The JavaScript implementation of the Dash Platform Protocol",
+  "scripts": {
+    "lint": "eslint .",
+    "test": "yarn run test:coverage && yarn run test:browsers",
+    "build:web": "webpack --stats-error-details",
+    "test:node": "NODE_ENV=test mocha",
+    "test:browsers": "karma start ./karma.conf.js --single-run",
+    "test:coverage": "NODE_ENV=test nyc --check-coverage --stmts=98 --branch=94 --funcs=95 --lines=97 yarn run mocha 'test/unit/**/*.spec.js' 'test/integration/**/*.spec.js'",
+    "prepublishOnly": "yarn run build:web"
+  },
+  "ultra": {
+    "concurrent": [
+      "test"
+    ]
+  },
+  "main": "lib/index.js",
+  "contributors": [
+    {
+      "name": "Anton Suprunchuk",
+      "email": "anton.suprunchuk@dash.org",
+      "url": "https://github.com/antouhou"
+    },
+    {
+      "name": "Ivan Shumkov",
+      "email": "ivan@shumkov.ru",
+      "url": "https://github.com/shumkov"
+    },
+    {
+      "name": "Djavid Gabibiyan",
+      "email": "djavid@dash.org",
+      "url": "https://github.com/jawid-h"
+    },
+    {
+      "name": "Konstantin Shuplenkov",
+      "email": "konstantin.shuplenkov@dash.org",
+      "url": "https://github.com/shuplenkov"
+    }
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/core": "^7.15.5",
+    "@babel/preset-env": "^7.15.4",
+    "acorn": "^8.5.0",
+    "assert": "^2.0.0",
+    "babel-loader": "^8.2.2",
+    "buffer": "^6.0.3",
+    "chai": "^4.3.4",
+    "chai-as-promised": "^7.1.1",
+    "chai-exclude": "^2.1.0",
+    "chai-string": "^1.5.0",
+    "core-js": "^3.17.2",
+    "crypto-browserify": "^3.12.0",
+    "dirty-chai": "^2.0.1",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.24.2",
+    "events": "^3.3.0",
+    "https-browserify": "^1.0.0",
+    "karma": "^6.4.1",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-firefox-launcher": "^2.1.1",
+    "karma-mocha": "^2.0.1",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-webpack": "^5.0.0",
+    "mocha": "^9.1.2",
+    "node-inspect-extracted": "^1.0.8",
+    "nyc": "^15.1.0",
+    "path-browserify": "^1.0.1",
+    "process": "^0.11.10",
+    "sinon": "^11.1.2",
+    "sinon-chai": "^3.7.0",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "^3.2.0",
+    "string_decoder": "^1.3.0",
+    "url": "^0.11.0",
+    "util": "^0.12.4",
+    "webpack": "^5.59.1",
+    "webpack-cli": "^4.9.1"
+  },
+  "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^8.0.0",
+    "@dashevo/dashcore-lib": "~0.19.44",
+    "@dashevo/dashpay-contract": "~0.24.0-dev.1",
+    "@dashevo/dpns-contract": "~0.24.0-dev.1",
+    "@dashevo/feature-flags-contract": "~0.24.0-dev.1",
+    "@dashevo/masternode-reward-shares-contract": "~0.24.0-dev.1",
+    "@dashevo/wasm-re2": "~1.0.2",
+    "ajv": "^8.6.0",
+    "ajv-formats": "^2.1.1",
+    "bignumber.js": "^9.0.1",
+    "bls-signatures": "^0.2.5",
+    "bs58": "^4.0.1",
+    "cbor": "^8.0.0",
+    "fast-json-patch": "^3.1.0",
+    "json-schema-diff-validator": "^0.4.1",
+    "json-schema-traverse": "^1.0.0",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.clonedeepwith": "^4.5.0",
+    "lodash.get": "^4.4.2",
+    "lodash.set": "^4.3.2",
+    "long": "^5.2.0"
+  }
+}

package/test/.eslintrc

@@ -0,0 +1,12 @@
+{
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "rules": {
+    "import/no-extraneous-dependencies": "off"
+  },
+  "globals": {
+    "expect": true
+  }
+}

package/test/integration/DashPlatformProtocol.spec.js

@@ -0,0 +1,53 @@
+const DashPlatformProtocol = require('../../lib/DashPlatformProtocol');
+const protocolVersion = require('../../lib/version/protocolVersion');
+const getChainAssetLockProofFixture = require('../../lib/test/fixtures/getChainAssetLockProofFixture');
+const generateRandomIdentifier = require('../../lib/test/utils/generateRandomIdentifier');
+
+describe('DashPlatformProtocol', () => {
+  let dpp;
+
+  beforeEach(async () => {
+    dpp = new DashPlatformProtocol({});
+    await dpp.initialize();
+  });
+
+  it('should propagate protocol version to factories', async () => {
+    let dataContract = dpp.dataContract.create(generateRandomIdentifier(), {
+      niceDocument: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+          },
+        },
+        required: ['$createdAt'],
+        additionalProperties: false,
+      },
+    });
+    const document = dpp.document.create(dataContract, generateRandomIdentifier(), 'niceDocument', {});
+    let identity = dpp.identity.create(getChainAssetLockProofFixture(), []);
+
+    expect(dataContract.protocolVersion).to.equal(protocolVersion.latestVersion);
+    expect(document.protocolVersion).to.equal(protocolVersion.latestVersion);
+    expect(identity.protocolVersion).to.equal(protocolVersion.latestVersion);
+
+    dpp.setProtocolVersion(42);
+
+    dataContract = dpp.dataContract.create(generateRandomIdentifier(), {
+      niceDocument: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+          },
+        },
+        required: ['$createdAt'],
+        additionalProperties: false,
+      },
+    });
+    identity = dpp.identity.create(getChainAssetLockProofFixture(), []);
+
+    expect(dataContract.protocolVersion).to.equal(42);
+    expect(identity.protocolVersion).to.equal(42);
+  });
+});

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

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

package/test/integration/dataContract/DataContractFacade.spec.js

@@ -0,0 +1,84 @@
+const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
+
+const DataContract = require('../../../lib/dataContract/DataContract');
+
+const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+
+const DataContractFactory = require('../../../lib/dataContract/DataContractFactory');
+
+describe('DataContractFacade', () => {
+  let dpp;
+  let dataContract;
+  let dataContractFactory;
+
+  beforeEach(async () => {
+    dpp = new DashPlatformProtocol();
+    await dpp.initialize();
+
+    dataContract = getDataContractFixture();
+
+    dataContractFactory = new DataContractFactory(
+      dpp,
+      undefined,
+      undefined,
+    );
+  });
+
+  describe('create', () => {
+    it('should create DataContract', () => {
+      const result = dpp.dataContract.create(
+        dataContract.getOwnerId(),
+        dataContract.getDocuments(),
+      );
+
+      expect(result).to.be.an.instanceOf(DataContract);
+
+      expect(result.getOwnerId()).to.deep.equal(dataContract.getOwnerId());
+      expect(result.getDocuments()).to.equal(dataContract.getDocuments());
+    });
+  });
+
+  describe('createFromObject', () => {
+    it('should create DataContract from plain object', async () => {
+      const result = await dpp.dataContract.createFromObject(dataContract.toObject());
+
+      expect(result).to.be.an.instanceOf(DataContract);
+
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    it('should create DataContract from string', async () => {
+      const result = await dpp.dataContract.createFromBuffer(dataContract.toBuffer());
+
+      expect(result).to.be.an.instanceOf(DataContract);
+
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+    });
+  });
+
+  describe('createDataContractCreateTransition', () => {
+    it('should create DataContractCreateTransition from DataContract', () => {
+      const stateTransition = dataContractFactory.createDataContractCreateTransition(dataContract);
+
+      const result = dpp.dataContract.createDataContractCreateTransition(dataContract);
+
+      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+
+      expect(result.toObject()).to.deep.equal(stateTransition.toObject());
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate DataContract', async () => {
+      const result = await dpp.dataContract.validate(dataContract);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+    });
+  });
+});