feat!: validate protocol version (#336)

Author: shumkov

lib/DashPlatformProtocol.js

@@ -1,7 +1,7 @@
 const { default: getRE2Class } = require('@dashevo/re2-wasm');
 const createAjv = require('./ajv/createAjv');
 
-const { protocolVersion } = require('./protocolVersion');
+const protocolVersion = require('./protocolVersion');
 
 const JsonSchemaValidator = require('./validation/JsonSchemaValidator');
 
@@ -26,7 +26,7 @@ class DashPlatformProtocol {
 
     this.protocolVersion = this.options.protocolVersion !== undefined
       ? this.options.protocolVersion
-      : protocolVersion;
+      : protocolVersion.latestVersion;
 
     this.stateRepository = undefined;
     this.jsonSchemaValidator = undefined;

lib/dataContract/DataContractFacade.js

@@ -6,6 +6,9 @@ const validateDataContractFactory = require('./validation/validateDataContractFa
 const enrichDataContractWithBaseSchema = require('./enrichDataContractWithBaseSchema');
 const validateDataContractMaxDepthFactory = require('./validation/validateDataContractMaxDepthFactory');
 const validateDataContractPatternsFactory = require('./validation/validateDataContractPatternsFactory');
+const decodeProtocolEntityFactory = require('../decodeProtocolEntityFactory');
+
+const protocolVersion = require('../protocolVersion');
 
 class DataContractFacade {
   /**
@@ -25,9 +28,12 @@ class DataContractFacade {
       RE2,
     );
 
+    const decodeProtocolEntity = decodeProtocolEntityFactory(protocolVersion.compatibility);
+
     this.factory = new DataContractFactory(
       dpp,
       this.validateDataContract,
+      decodeProtocolEntity,
     );
   }
 

lib/dataContract/DataContractFactory.js

@@ -5,20 +5,19 @@ const generateDataContractId = require('./generateDataContractId');
 
 const DataContractCreateTransition = require('./stateTransition/DataContractCreateTransition/DataContractCreateTransition');
 
-const SerializedObjectParsingError = require('../errors/SerializedObjectParsingError');
-
 const generateEntropy = require('../util/generateEntropy');
-
-const { decode } = require('../util/serializer');
+const ConsensusError = require('../errors/ConsensusError');
 
 class DataContractFactory {
   /**
    * @param {DashPlatformProtocol} dpp
    * @param {validateDataContract} validateDataContract
+   * @param {decodeProtocolEntity} decodeProtocolEntity
    */
-  constructor(dpp, validateDataContract) {
+  constructor(dpp, validateDataContract, decodeProtocolEntity) {
     this.dpp = dpp;
     this.validateDataContract = validateDataContract;
+    this.decodeProtocolEntity = decodeProtocolEntity;
   }
 
   /**
@@ -79,17 +78,21 @@ class DataContractFactory {
    */
   async createFromBuffer(buffer, options = { }) {
     let rawDataContract;
+    let protocolVersion;
+
     try {
-      // first 4 bytes are protocol version
-      rawDataContract = decode(buffer.slice(4, buffer.length));
-      rawDataContract.protocolVersion = buffer.slice(0, 4).readUInt32BE(0);
+      [protocolVersion, rawDataContract] = this.decodeProtocolEntity(
+        buffer,
+        this.dpp.getProtocolVersion(),
+      );
+
+      rawDataContract.protocolVersion = protocolVersion;
     } catch (error) {
-      throw new InvalidDataContractError([
-        new SerializedObjectParsingError(
-          buffer,
-          error,
-        ),
-      ]);
+      if (error instanceof ConsensusError) {
+        throw new InvalidDataContractError([error]);
+      }
+
+      throw error;
     }
 
     return this.createFromObject(rawDataContract, options);

lib/decodeProtocolEntityFactory.js

@@ -0,0 +1,70 @@
+const ProtocolVersionParsingError = require('./errors/ProtocolVersionParsingError');
+const SerializedObjectParsingError = require('./errors/SerializedObjectParsingError');
+const UnsupportedProtocolVersionError = require('./errors/UnsupportedProtocolVersionError');
+const IncompatibleProtocolVersionError = require('./errors/IncompatibleProtocolVersionError');
+const CompatibleProtocolVersionIsNotDefinedError = require('./errors/CompatibleProtocolVersionIsNotDefinedError');
+
+const { decode } = require('./util/serializer');
+
+function decodeProtocolEntityFactory(versionCompatibilityMap) {
+  /**
+   * @typedef {decodeProtocolEntity}
+   * @param {Buffer} buffer
+   * @param {number} currentProtocolVersion
+   * @return {[number, Object]}
+   */
+  function decodeProtocolEntity(buffer, currentProtocolVersion) {
+    // Parse protocol version from the first 4 bytes
+    let protocolVersion;
+    try {
+      protocolVersion = buffer.slice(0, 4).readUInt32BE(0);
+    } catch (error) {
+      throw new ProtocolVersionParsingError(
+        buffer,
+        error,
+      );
+    }
+
+    // Parsed protocol version must be equal or lower than current version
+    if (protocolVersion > currentProtocolVersion) {
+      throw new UnsupportedProtocolVersionError(
+        buffer,
+        protocolVersion,
+        currentProtocolVersion,
+      );
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(versionCompatibilityMap, currentProtocolVersion)) {
+      throw new CompatibleProtocolVersionIsNotDefinedError(currentProtocolVersion);
+    }
+
+    const minimalProtocolVersion = versionCompatibilityMap[currentProtocolVersion];
+
+    // Parsed protocol version must higher or equal to the minimum compatible version
+    if (protocolVersion < minimalProtocolVersion) {
+      throw new IncompatibleProtocolVersionError(
+        buffer,
+        protocolVersion,
+        minimalProtocolVersion,
+      );
+    }
+
+    let rawEntity;
+    try {
+      rawEntity = decode(
+        buffer.slice(4, buffer.length),
+      );
+    } catch (error) {
+      throw new SerializedObjectParsingError(
+        buffer,
+        error,
+      );
+    }
+
+    return [protocolVersion, rawEntity];
+  }
+
+  return decodeProtocolEntity;
+}
+
+module.exports = decodeProtocolEntityFactory;

lib/document/DocumentFacade.js

@@ -6,6 +6,9 @@ const Document = require('./Document');
 const DocumentFactory = require('./DocumentFactory');
 
 const MissingOptionError = require('../errors/MissingOptionError');
+const decodeProtocolEntityFactory = require('../decodeProtocolEntityFactory');
+
+const protocolVersion = require('../protocolVersion');
 
 class DocumentFacade {
   /**
@@ -23,10 +26,13 @@ class DocumentFacade {
       this.stateRepository,
     );
 
+    const decodeProtocolEntity = decodeProtocolEntityFactory(protocolVersion.compatibility);
+
     this.factory = new DocumentFactory(
       dpp,
       this.validateDocument,
       this.fetchAndValidateDataContract,
+      decodeProtocolEntity,
     );
   }
 

lib/document/DocumentFactory.js

@@ -1,34 +1,38 @@
 const Document = require('./Document');
 
-const { decode } = require('../util/serializer');
 const generateEntropy = require('../util/generateEntropy');
+const generateDocumentId = require('./generateDocumentId');
 
 const DocumentsBatchTransition = require('./stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
 
 const AbstractDocumentTransition = require('./stateTransition/DocumentsBatchTransition/documentTransition/AbstractDocumentTransition');
 const DocumentCreateTransition = require('./stateTransition/DocumentsBatchTransition/documentTransition/DocumentCreateTransition');
 
+const ConsensusError = require('../errors/ConsensusError');
 const InvalidActionNameError = require('./errors/InvalidActionNameError');
 const NoDocumentsSuppliedError = require('./errors/NoDocumentsSuppliedError');
 const MismatchOwnerIdsError = require('./errors/MismatchOwnerIdsError');
 const InvalidInitialRevisionError = require('./errors/InvalidInitialRevisionError');
-
 const InvalidDocumentError = require('./errors/InvalidDocumentError');
 const InvalidDocumentTypeError = require('../errors/InvalidDocumentTypeError');
-const SerializedObjectParsingError = require('../errors/SerializedObjectParsingError');
-
-const generateDocumentId = require('./generateDocumentId');
 
 class DocumentFactory {
   /**
    * @param {DashPlatformProtocol} dpp
    * @param {validateDocument} validateDocument
    * @param {fetchAndValidateDataContract} fetchAndValidateDataContract
+   * @param {decodeProtocolEntity} decodeProtocolEntity
    */
-  constructor(dpp, validateDocument, fetchAndValidateDataContract) {
+  constructor(
+    dpp,
+    validateDocument,
+    fetchAndValidateDataContract,
+    decodeProtocolEntity,
+  ) {
     this.dpp = dpp;
     this.validateDocument = validateDocument;
     this.fetchAndValidateDataContract = fetchAndValidateDataContract;
+    this.decodeProtocolEntity = decodeProtocolEntity;
   }
 
   /**
@@ -160,17 +164,21 @@ class DocumentFactory {
    */
   async createFromBuffer(buffer, options = { }) {
     let rawDocument;
+    let protocolVersion;
+
     try {
-      // first 4 bytes are protocol version
-      rawDocument = decode(buffer.slice(4, buffer.length));
-      rawDocument.$protocolVersion = buffer.slice(0, 4).readUInt32BE(0);
+      [protocolVersion, rawDocument] = this.decodeProtocolEntity(
+        buffer,
+        this.dpp.getProtocolVersion(),
+      );
+
+      rawDocument.$protocolVersion = protocolVersion;
     } catch (error) {
-      throw new InvalidDocumentError([
-        new SerializedObjectParsingError(
-          buffer,
-          error,
-        ),
-      ]);
+      if (error instanceof ConsensusError) {
+        throw new InvalidDocumentError([error]);
+      }
+
+      throw error;
     }
 
     return this.createFromObject(rawDocument, options);

lib/errors/CompatibleProtocolVersionIsNotDefinedError.js

@@ -0,0 +1,26 @@
+class CompatibleProtocolVersionIsNotDefinedError extends Error {
+  /**
+   * @param {number} currentProtocolVersion
+   */
+  constructor(currentProtocolVersion) {
+    super();
+
+    this.name = this.constructor.name;
+    this.message = `Compatible version is not defined for protocol version ${currentProtocolVersion}`;
+
+    this.currentProtocolVersion = currentProtocolVersion;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  /**
+   * @return {number}
+   */
+  getCurrentProtocolVersion() {
+    return this.currentProtocolVersion;
+  }
+}
+
+module.exports = CompatibleProtocolVersionIsNotDefinedError;

lib/errors/IncompatibleProtocolVersionError.js

@@ -0,0 +1,43 @@
+const ConsensusError = require('./ConsensusError');
+
+class IncompatibleProtocolVersionError extends ConsensusError {
+  /**
+   * @param {Buffer} payload
+   * @param {number} parsedProtocolVersion
+   * @param {number} minimalProtocolVersion
+   */
+  constructor(payload, parsedProtocolVersion, minimalProtocolVersion) {
+    super(
+      `Protocol version ${parsedProtocolVersion} is not supported. Minimal supported protocol version is ${minimalProtocolVersion}`,
+    );
+
+    this.payload = payload;
+    this.parsedProtocolVersion = parsedProtocolVersion;
+    this.minimalProtocolVersion = minimalProtocolVersion;
+  }
+
+  /**
+   * Get object payload
+   *
+   * @return {Buffer}
+   */
+  getPayload() {
+    return this.payload;
+  }
+
+  /**
+   * @return {number}
+   */
+  getParsedProtocolVersion() {
+    return this.parsedProtocolVersion;
+  }
+
+  /**
+   * @return {number}
+   */
+  getMinimalProtocolVersion() {
+    return this.minimalProtocolVersion;
+  }
+}
+
+module.exports = IncompatibleProtocolVersionError;

lib/errors/ProtocolVersionParsingError.js

@@ -0,0 +1,36 @@
+const ConsensusError = require('./ConsensusError');
+
+class ProtocolVersionParsingError extends ConsensusError {
+  /**
+   * @param {Buffer} payload
+   * @param {Error} parsingError
+   */
+  constructor(payload, parsingError) {
+    super(
+      `Can't read protocol version from serialized object: ${parsingError.message}`,
+    );
+
+    this.payload = payload;
+    this.parsingError = parsingError;
+  }
+
+  /**
+   * Get object payload
+   *
+   * @return {Buffer}
+   */
+  getPayload() {
+    return this.payload;
+  }
+
+  /**
+   * Get parsing error
+   *
+   * @return {Error}
+   */
+  getParsingError() {
+    return this.parsingError;
+  }
+}
+
+module.exports = ProtocolVersionParsingError;

lib/errors/SerializedObjectParsingError.js

@@ -2,7 +2,7 @@ const ConsensusError = require('./ConsensusError');
 
 class SerializedObjectParsingError extends ConsensusError {
   /**
-   * @param {Buffer|string} payload
+   * @param {Buffer} payload
    * @param {Error} parsingError
    */
   constructor(payload, parsingError) {
@@ -15,9 +15,9 @@ class SerializedObjectParsingError extends ConsensusError {
   }
 
   /**
-   * Get object payload
+   * Get payload
    *
-   * @return {Buffer|string}
+   * @return {Buffer}
    */
   getPayload() {
     return this.payload;