refactor: fix tests, fetchAssetLockPublicKeyHashFactory

lib/dataContract/stateTransition/DataContractCreateTransition/validation/basic/validateDataContractCreateTransitionBasicFactory.js

@@ -1,5 +1,3 @@
-const DataContractCreateTransition = require('../../DataContractCreateTransition');
-
 const InvalidDataContractIdError = require('../../../../../errors/InvalidDataContractIdError');
 
 const generateDataContractId = require('../../../../generateDataContractId');
@@ -11,19 +9,18 @@ const dataContractCreateTransitionSchema = require('../../../../../../schema/dat
 /**
  * @param {JsonSchemaValidator} jsonSchemaValidator
  * @param {validateDataContract} validateDataContract
- * @param {validateStateTransitionSignature} validateStateTransitionSignature
- * @return {validateDataContractCreateTransitionStructure}
+ * @return {validateDataContractCreateTransitionBasic}
  */
 function validateDataContractCreateTransitionBasicFactory(
   jsonSchemaValidator,
   validateDataContract,
 ) {
   /**
-   * @typedef validateDataContractCreateTransitionStructure
+   * @typedef validateDataContractCreateTransitionBasic
    * @param {RawDataContractCreateTransition} rawStateTransition
    * @return {ValidationResult}
    */
-  async function validateDataContractCreateTransitionStructure(rawStateTransition) {
+  async function validateDataContractCreateTransitionBasic(rawStateTransition) {
     const result = jsonSchemaValidator.validate(
       dataContractCreateTransitionSchema,
       convertBuffersToArrays(rawStateTransition),
@@ -58,7 +55,7 @@ function validateDataContractCreateTransitionBasicFactory(
     return result;
   }
 
-  return validateDataContractCreateTransitionStructure;
+  return validateDataContractCreateTransitionBasic;
 }
 
 module.exports = validateDataContractCreateTransitionBasicFactory;

lib/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory.js

@@ -5,15 +5,15 @@ const DataContractAlreadyPresentError = require('../../../../../errors/DataContr
 /**
  *
  * @param {StateRepository} stateRepository
- * @return {validateDataContractCreateTransitionData}
+ * @return {validateDataContractCreateTransitionState}
  */
 function validateDataContractCreateTransitionStateFactory(stateRepository) {
   /**
-   * @typedef validateDataContractCreateTransitionData
+   * @typedef validateDataContractCreateTransitionState
    * @param {DataContractCreateTransition} stateTransition
    * @return {ValidationResult}
    */
-  async function validateDataContractCreateTransitionData(stateTransition) {
+  async function validateDataContractCreateTransitionState(stateTransition) {
     const result = new ValidationResult();
 
     const dataContract = stateTransition.getDataContract();
@@ -31,7 +31,7 @@ function validateDataContractCreateTransitionStateFactory(stateRepository) {
     return result;
   }
 
-  return validateDataContractCreateTransitionData;
+  return validateDataContractCreateTransitionState;
 }
 
 module.exports = validateDataContractCreateTransitionStateFactory;

lib/document/stateTransition/DocumentsBatchTransition/validation/basic/validateDocumentsBatchTransitionBasicFactory.js

@@ -30,7 +30,7 @@ const createAndValidateIdentifier = require('../../../../../identifier/createAnd
  * @param {enrichDataContractWithBaseSchema} enrichDataContractWithBaseSchema
  * @param {validatePartialCompoundIndices} validatePartialCompoundIndices
  *
- * @return {validateDocumentsBatchTransitionStructure}
+ * @return {validateDocumentsBatchTransitionBasic}
  */
 function validateDocumentsBatchTransitionBasicFactory(
   findDuplicatesById,
@@ -215,11 +215,11 @@ function validateDocumentsBatchTransitionBasicFactory(
   }
 
   /**
-   * @typedef validateDocumentsBatchTransitionStructure
+   * @typedef validateDocumentsBatchTransitionBasic
    * @param {RawDocumentsBatchTransition} rawStateTransition
    * @return {ValidationResult}
    */
-  async function validateDocumentsBatchTransitionStructure(rawStateTransition) {
+  async function validateDocumentsBatchTransitionBasic(rawStateTransition) {
     const result = jsonSchemaValidator.validate(
       documentsBatchTransitionSchema,
       convertBuffersToArrays(rawStateTransition),
@@ -295,7 +295,7 @@ function validateDocumentsBatchTransitionBasicFactory(
     return result;
   }
 
-  return validateDocumentsBatchTransitionStructure;
+  return validateDocumentsBatchTransitionBasic;
 }
 
 module.exports = validateDocumentsBatchTransitionBasicFactory;

lib/document/stateTransition/DocumentsBatchTransition/validation/basic/validatePartialCompoundIndices.js

@@ -1,3 +1,5 @@
+const lodashGet = require('lodash.get');
+
 const ValidationResult = require('../../../../../validation/ValidationResult');
 
 const InconsistentCompoundIndexDataError = require('../../../../../errors/InconsistentCompoundIndexDataError');
@@ -8,26 +10,24 @@ const InconsistentCompoundIndexDataError = require('../../../../../errors/Incons
  * @param {Array<
  *         RawDocumentCreateTransition|
  *         RawDocumentReplaceTransition
- *         >} documentTransitions
+ *         >} rawDocumentTransitions
  * @param {DataContract} dataContract
  * @return {ValidationResult}
  */
 function validatePartialCompoundIndices(
   ownerId,
-  documentTransitions,
+  rawDocumentTransitions,
   dataContract,
 ) {
   const result = new ValidationResult();
 
-  documentTransitions.forEach((documentTransition) => {
-    const documentSchema = dataContract.getDocumentSchema(documentTransition.$type);
+  rawDocumentTransitions.forEach((rawDocumentTransition) => {
+    const documentSchema = dataContract.getDocumentSchema(rawDocumentTransition.$type);
 
     if (!documentSchema.indices) {
       return;
     }
 
-    const rawDocumentTransition = documentTransition.toObject();
-
     documentSchema.indices
       .filter((index) => index.unique && index.properties.length > 1)
       .forEach((indexDefinition) => {
@@ -42,7 +42,7 @@ function validatePartialCompoundIndices(
             return rawDocumentTransition[propertyPath];
           }
 
-          return documentTransition.get(propertyPath);
+          return lodashGet(rawDocumentTransition, propertyPath);
         });
 
         const allAreDefined = data.every((item) => item !== undefined);
@@ -52,7 +52,7 @@ function validatePartialCompoundIndices(
 
         if (!isOk) {
           result.addError(new InconsistentCompoundIndexDataError(
-            documentTransition.getType(),
+            rawDocumentTransition.$type,
             indexDefinition,
           ));
         }

lib/document/stateTransition/DocumentsBatchTransition/validation/state/validateDocumentsBatchTransitionStateFactory.js

@@ -24,15 +24,13 @@ const BLOCK_TIME_WINDOW_MINUTES = 5;
  * @param {StateRepository} stateRepository
  * @param {fetchDocuments} fetchDocuments
  * @param {validateDocumentsUniquenessByIndices} validateDocumentsUniquenessByIndices
- * @param {validatePartialCompoundIndices} validatePartialCompoundIndices
  * @param {executeDataTriggers} executeDataTriggers
- * @return {validateDocumentsBatchTransitionData}
+ * @return {validateDocumentsBatchTransitionState}
  */
 function validateDocumentsBatchTransitionStateFactory(
   stateRepository,
   fetchDocuments,
   validateDocumentsUniquenessByIndices,
-  validatePartialCompoundIndices,
   executeDataTriggers,
 ) {
   /**
@@ -221,11 +219,11 @@ function validateDocumentsBatchTransitionStateFactory(
     return result;
   }
   /**
-   * @typedef validateDocumentsBatchTransitionData
+   * @typedef validateDocumentsBatchTransitionState
    * @param {DocumentsBatchTransition} stateTransition
    * @return {ValidationResult}
    */
-  async function validateDocumentsBatchTransitionData(stateTransition) {
+  async function validateDocumentsBatchTransitionState(stateTransition) {
     const result = new ValidationResult();
 
     const ownerId = stateTransition.getOwnerId();
@@ -257,7 +255,7 @@ function validateDocumentsBatchTransitionStateFactory(
     return result;
   }
 
-  return validateDocumentsBatchTransitionData;
+  return validateDocumentsBatchTransitionState;
 }
 
 module.exports = validateDocumentsBatchTransitionStateFactory;

lib/identity/stateTransition/IdentityCreateTransition/validation/basic/validateIdentityCreateTransitionBasicFactory.js

@@ -5,22 +5,20 @@ const convertBuffersToArrays = require('../../../../../util/convertBuffersToArra
 /**
  * @param {JsonSchemaValidator} jsonSchemaValidator
  * @param {validatePublicKeys} validatePublicKeys
- * @param {validateSignatureAgainstAssetLockPublicKey} validateSignatureAgainstAssetLockPublicKey
  * @param {Object.<number, Function>} proofValidationFunctionsByType
- * @return {validateIdentityCreateTransitionStructure}
+ * @return {validateIdentityCreateTransitionBasic}
  */
 function validateIdentityCreateTransitionBasicFactory(
   jsonSchemaValidator,
   validatePublicKeys,
-  validateSignatureAgainstAssetLockPublicKey,
   proofValidationFunctionsByType,
 ) {
   /**
-   * @typedef validateIdentityCreateTransitionStructure
+   * @typedef validateIdentityCreateTransitionBasic
    * @param {RawIdentityCreateTransition} rawStateTransition
    * @return {Promise<ValidationResult>}
    */
-  async function validateIdentityCreateTransitionStructure(rawStateTransition) {
+  async function validateIdentityCreateTransitionBasic(rawStateTransition) {
     // Validate state transition against JSON Schema
     const result = jsonSchemaValidator.validate(
       identityCreateTransitionSchema,
@@ -54,7 +52,7 @@ function validateIdentityCreateTransitionBasicFactory(
     return result;
   }
 
-  return validateIdentityCreateTransitionStructure;
+  return validateIdentityCreateTransitionBasic;
 }
 
 module.exports = validateIdentityCreateTransitionBasicFactory;

lib/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory.js

@@ -5,7 +5,7 @@ const IdentityAlreadyExistsError = require('../../../../../errors/IdentityAlread
 /**
  * @param {StateRepository} stateRepository
  * @param {validateIdentityPublicKeysUniqueness} validateIdentityPublicKeysUniqueness
- * @return {validateIdentityCreateTransitionData}
+ * @return {validateIdentityCreateTransitionState}
  */
 function validateIdentityCreateTransitionStateFactory(
   stateRepository,
@@ -21,11 +21,11 @@ function validateIdentityCreateTransitionStateFactory(
    */
 
   /**
-   * @typedef validateIdentityCreateTransitionData
+   * @typedef {validateIdentityCreateTransitionState}
    * @param {IdentityCreateTransition} stateTransition
    * @return {ValidationResult}
    */
-  async function validateIdentityCreateTransitionData(stateTransition) {
+  async function validateIdentityCreateTransitionState(stateTransition) {
     const result = new ValidationResult();
 
     // Check if identity with such id already exists
@@ -49,7 +49,7 @@ function validateIdentityCreateTransitionStateFactory(
     return result;
   }
 
-  return validateIdentityCreateTransitionData;
+  return validateIdentityCreateTransitionState;
 }
 
 module.exports = validateIdentityCreateTransitionStateFactory;

lib/identity/stateTransition/IdentityTopUpTransition/validation/basic/validateIdentityTopUpTransitionBasicFactory.js

@@ -6,22 +6,20 @@ const Identifier = require('../../../../../identifier/Identifier');
 /**
  * @param {JsonSchemaValidator} jsonSchemaValidator
  * @param {validateIdentityExistence} validateIdentityExistence
- * @param {validateSignatureAgainstAssetLockPublicKey} validateSignatureAgainstAssetLockPublicKey
  * @param {Object.<number, Function>} proofValidationFunctionsByType
- * @return {validateIdentityTopUpTransitionStructure}
+ * @return {validateIdentityTopUpTransitionBasic}
  */
 function validateIdentityTopUpTransitionBasicFactory(
   jsonSchemaValidator,
   validateIdentityExistence,
-  validateSignatureAgainstAssetLockPublicKey,
   proofValidationFunctionsByType,
 ) {
   /**
-   * @typedef {validateIdentityTopUpTransitionStructure}
+   * @typedef {validateIdentityTopUpTransitionBasic}
    * @param {RawIdentityTopUpTransition} rawStateTransition
    * @return {ValidationResult}
    */
-  async function validateIdentityTopUpTransitionStructure(rawStateTransition) {
+  async function validateIdentityTopUpTransitionBasic(rawStateTransition) {
     const result = jsonSchemaValidator.validate(
       identityTopUpTransitionSchema,
       convertBuffersToArrays(rawStateTransition),
@@ -56,7 +54,7 @@ function validateIdentityTopUpTransitionBasicFactory(
     return result;
   }
 
-  return validateIdentityTopUpTransitionStructure;
+  return validateIdentityTopUpTransitionBasic;
 }
 
 module.exports = validateIdentityTopUpTransitionBasicFactory;

lib/identity/stateTransition/IdentityTopUpTransition/validation/state/validateIdentityTopUpTransitionStateFactory.js

@@ -1,20 +1,20 @@
 const ValidationResult = require('../../../../../validation/ValidationResult');
 
 /**
- * @return {validateIdentityTopUpTransitionData}
+ * @return {validateIdentityTopUpTransitionState}
  */
 function validateIdentityTopUpTransitionStateFactory() {
   /**
-   * @typedef validateIdentityTopUpTransitionData
+   * @typedef {validateIdentityTopUpTransitionState}
    * @param {IdentityTopUpTransition} stateTransition
-   * @return {ValidationResult}
+   * @return {Promise<ValidationResult>}
    */
   // eslint-disable-next-line no-unused-vars
-  async function validateIdentityTopUpTransitionData(stateTransition) {
+  async function validateIdentityTopUpTransitionState(stateTransition) {
     return new ValidationResult();
   }
 
-  return validateIdentityTopUpTransitionData;
+  return validateIdentityTopUpTransitionState;
 }
 
 module.exports = validateIdentityTopUpTransitionStateFactory;

lib/identity/stateTransition/assetLockProof/fetchAssetLockPublicKeyHash.js

@@ -0,0 +1,49 @@
+const { Transaction } = require('@dashevo/dashcore-lib');
+
+const InstantAssetLockProof = require('./instant/InstantAssetLockProof');
+const ChainAssetLockProof = require('./chain/ChainAssetLockProof');
+
+/**
+ * @param {StateRepository} stateRepository
+ * @return {fetchAssetLockPublicKeyHash}
+ */
+function fetchAssetLockPublicKeyHashFactory(stateRepository) {
+  /**
+   * @typedef {fetchAssetLockPublicKeyHash}
+   * @param {InstantAssetLockProof|ChainAssetLockProof} assetLockProof
+   * @return {Promise<Buffer>}
+   */
+  async function fetchAssetLockPublicKeyHash(assetLockProof) {
+    let transaction;
+    let outputIndex;
+
+    if (assetLockProof instanceof InstantAssetLockProof) {
+      transaction = assetLockProof.getTransaction();
+      outputIndex = assetLockProof.getOutputIndex();
+    } else if (assetLockProof instanceof ChainAssetLockProof) {
+      const outPoint = Transaction.parseOutPointBuffer(assetLockProof.getOutPoint());
+
+      outputIndex = outPoint.outputIndex;
+
+      const rawTransaction = await stateRepository.fetchTransaction(outPoint.transactionHash);
+
+      if (!rawTransaction) {
+        throw new Error();
+      }
+
+      transaction = new Transaction(rawTransaction);
+    }
+
+    const output = transaction.outputs[outputIndex];
+
+    if (!output) {
+      throw new Error();
+    }
+
+    return output.script.getData();
+  }
+
+  return fetchAssetLockPublicKeyHash;
+}
+
+module.exports = fetchAssetLockPublicKeyHashFactory;