feat!: chain Asset Lock proof

lib/StateRepositoryInterface.js

@@ -130,21 +130,31 @@
  */
 
 /**
- * Check if AssetLock Transaction outPoint exists in spent list
+ * Store AssetLock Transaction outPoint in spent list
  *
  * @async
  * @method
- * @name StateRepository#checkAssetLockTransactionOutPointExists
+ * @name StateRepository#storeAssetLockTransactionOutPoint
  * @param {Buffer} outPointBuffer
- * @returns {Promise<boolean>}
+ * @returns {Promise<void>}
  */
 
 /**
- * Store AssetLock Transaction outPoint in spent list
+ * Verify AssetLock outPoint
  *
  * @async
  * @method
- * @name StateRepository#storeAssetLockTransactionOutPoint
+ * @name StateRepository#checkAssetLockTransactionOutPointAlreadyUsed
  * @param {Buffer} outPointBuffer
- * @returns {Promise<void>}
+ * @returns {Promise<boolean>}
+ */
+
+/**
+ * Verify AssetLock height
+ *
+ * @async
+ * @method
+ * @name StateRepository#verifyChainLockHeight
+ * @param {number} height
+ * @returns {Promise<boolean>}
  */

lib/errors/InvalidIdentityAssetLockProofHeightError.js

@@ -0,0 +1,23 @@
+const ConsensusError = require('./ConsensusError');
+
+class InvalidIdentityAssetLockProofHeightError extends ConsensusError {
+  /**
+   *
+   * @param {number} height
+   */
+  constructor(height) {
+    super('Asset lock proof height is greater than consensus height');
+
+    this.height = height;
+  }
+
+  /**
+   *
+   * @returns {number}
+   */
+  getHeight() {
+    return this.height;
+  }
+}
+
+module.exports = InvalidIdentityAssetLockProofHeightError;

lib/errors/InvalidIdentityAssetLockProofOutPointError.js

@@ -0,0 +1,23 @@
+const ConsensusError = require('./ConsensusError');
+
+class InvalidIdentityAssetLockProofOutPointError extends ConsensusError {
+  /**
+   *
+   * @param {Buffer} outPoint
+   */
+  constructor(outPoint) {
+    super('Asset lock proof outPoint was already used');
+
+    this.outPoint = outPoint;
+  }
+
+  /**
+   *
+   * @returns {Buffer}
+   */
+  getOutPoint() {
+    return this.outPoint;
+  }
+}
+
+module.exports = InvalidIdentityAssetLockProofOutPointError;

lib/identity/IdentityFacade.js

@@ -26,16 +26,12 @@ class IdentityFacade {
   /**
    * Create Identity
    *
-   * @param {Transaction} assetLockTransaction
-   * @param {number} outputIndex
    * @param {InstantAssetLockProof} assetLockProof
    * @param {PublicKey[]} publicKeys
    * @return {Identity}
    */
-  create(assetLockTransaction, outputIndex, assetLockProof, publicKeys) {
+  create(assetLockProof, publicKeys) {
     return this.factory.create(
-      assetLockTransaction,
-      outputIndex,
       assetLockProof,
       publicKeys,
     );
@@ -86,10 +82,11 @@ class IdentityFacade {
    * Create Asset Lock with proofs
    *
    * @param {InstantLock} instantLock
+   * @param {Transaction} assetLockTransaction
    * @returns {InstantAssetLockProof}
    */
-  createInstantAssetLockProof(instantLock) {
-    return this.factory.createInstantAssetLockProof(instantLock);
+  createInstantAssetLockProof(instantLock, assetLockTransaction) {
+    return this.factory.createInstantAssetLockProof(instantLock, assetLockTransaction);
   }
 
   /**
@@ -106,16 +103,12 @@ class IdentityFacade {
    * Create identity top up transition
    *
    * @param {Identifier|Buffer|string} identityId - identity to top up
-   * @param {Transaction} assetLockTransaction
-   * @param {number} outputIndex
    * @param {InstantAssetLockProof} assetLockProof
    * @return {IdentityTopUpTransition}
    */
-  createIdentityTopUpTransition(identityId, assetLockTransaction, outputIndex, assetLockProof) {
+  createIdentityTopUpTransition(identityId, assetLockProof) {
     return this.factory.createIdentityTopUpTransition(
       identityId,
-      assetLockTransaction,
-      outputIndex,
       assetLockProof,
     );
   }

lib/identity/IdentityFactory.js

@@ -22,16 +22,12 @@ class IdentityFactory {
   /**
    * Create Identity
    *
-   * @param {Transaction} assetLockTransaction
-   * @param {number} outputIndex
    * @param {InstantAssetLockProof} assetLockProof
    * @param {PublicKey[]} publicKeys
    * @return {Identity}
    */
-  create(assetLockTransaction, outputIndex, assetLockProof, publicKeys) {
+  create(assetLockProof, publicKeys) {
     const assetLock = new AssetLock({
-      transaction: assetLockTransaction.toBuffer(),
-      outputIndex,
       proof: assetLockProof.toObject(),
     });
 
@@ -102,11 +98,13 @@ class IdentityFactory {
    * Create Asset Lock with proofs
    *
    * @param {InstantLock} instantLock
+   * @param {Transaction} assetLockTransaction
    * @returns {InstantAssetLockProof}
    */
-  createInstantAssetLockProof(instantLock) {
+  createInstantAssetLockProof(instantLock, assetLockTransaction) {
     return new InstantAssetLockProof({
       instantLock: instantLock.toBuffer(),
+      transaction: assetLockTransaction.toBuffer(),
     });
   }
 
@@ -131,15 +129,11 @@ class IdentityFactory {
    * Create identity top up transition
    *
    * @param {Identifier|Buffer|string} identityId - identity to top up
-   * @param {Transaction} assetLockTransaction
-   * @param {number} outputIndex
    * @param {InstantAssetLockProof} assetLockProof
    * @return {IdentityTopUpTransition}
    */
-  createIdentityTopUpTransition(identityId, assetLockTransaction, outputIndex, assetLockProof) {
+  createIdentityTopUpTransition(identityId, assetLockProof) {
     const assetLock = new AssetLock({
-      transaction: assetLockTransaction.toBuffer(),
-      outputIndex,
       proof: assetLockProof.toObject(),
     });
 

lib/identity/stateTransitions/assetLock/AssetLock.js

@@ -1,55 +1,14 @@
-const { Transaction } = require('@dashevo/dashcore-lib');
-
-const hash = require('../../../util/hash');
-
 const InstantAssetLockProof = require('./proof/instant/InstantAssetLockProof');
-const Identifier = require('../../../identifier/Identifier');
+const ChainAssetLockProof = require('./proof/chain/ChainAssetLockProof');
 
 class AssetLock {
   /**
    * @param {RawAssetLock} rawAssetLock
    */
   constructor(rawAssetLock) {
-    this.outputIndex = rawAssetLock.outputIndex;
-    this.transaction = new Transaction(rawAssetLock.transaction);
     this.proof = new AssetLock.PROOF_CLASSES_BY_TYPES[rawAssetLock.proof.type](rawAssetLock.proof);
   }
 
-  /**
-   * Get asset lock transaction
-   *
-   * @returns {Transaction}
-   */
-  getTransaction() {
-    return this.transaction;
-  }
-
-  /**
-   * Get asset lock transaction output index
-   *
-   * @returns {number}
-   */
-  getOutputIndex() {
-    return this.outputIndex;
-  }
-
-  /**
-   * Get transaction output
-   *
-   * @returns {Output}
-   */
-  getOutput() {
-    return this.transaction.outputs[this.getOutputIndex()];
-  }
-
-  /**
-   * Get transaction outPoint
-   * @return {Buffer}
-   */
-  getOutPoint() {
-    return this.transaction.getOutPointBuffer(this.getOutputIndex());
-  }
-
   /**
    * Get proof
    *
@@ -65,9 +24,7 @@ class AssetLock {
    * @returns {Identifier}
    */
   createIdentifier() {
-    return new Identifier(
-      hash(this.getTransaction().getOutPointBuffer(this.getOutputIndex())),
-    );
+    return this.proof.createIdentifier();
   }
 
   /**
@@ -76,8 +33,6 @@ class AssetLock {
    */
   toObject() {
     return {
-      transaction: this.getTransaction().toBuffer(),
-      outputIndex: this.getOutputIndex(),
       proof: this.getProof().toObject(),
     };
   }
@@ -88,30 +43,28 @@ class AssetLock {
   toJSON() {
     return {
       ...this.toObject(),
-      transaction: this.getTransaction().toString('base64'),
       proof: this.getProof().toJSON(),
     };
   }
 }
 
 /**
  * @typedef {Object} RawAssetLock
- * @property {Buffer} transaction
- * @property {number} outputIndex
  * @property {RawInstantAssetLockProof} proof
  */
 
 /**
  * @typedef {Object} JsonAssetLock
- * @property {string} transaction
  * @property {number} outputIndex
  * @property {JsonInstantAssetLockProof} proof
  */
 
 AssetLock.PROOF_TYPE_INSTANT = 0;
+AssetLock.PROOF_TYPE_CHAIN = 1;
 
 AssetLock.PROOF_CLASSES_BY_TYPES = {
   [AssetLock.PROOF_TYPE_INSTANT]: InstantAssetLockProof,
+  [AssetLock.PROOF_TYPE_CHAIN]: ChainAssetLockProof,
 };
 
 module.exports = AssetLock;

lib/identity/stateTransitions/assetLock/proof/chain/ChainAssetLockProof.js

@@ -0,0 +1,92 @@
+const Identifier = require('../../../../../identifier/Identifier');
+const hash = require('../../../../../util/hash');
+
+class ChainAssetLockProof {
+  /**
+   * @param {RawChainAssetLockProof} rawAssetLockProof
+   */
+  constructor(rawAssetLockProof) {
+    this.height = rawAssetLockProof.height;
+    this.outPoint = rawAssetLockProof.outPoint;
+  }
+
+  /**
+   * Get proof type
+   *
+   * @returns {number}
+   */
+  getType() {
+    return 1;
+  }
+
+  /**
+   * Get height
+   *
+   * @returns {number}
+   */
+  getHeight() {
+    return this.height;
+  }
+
+  /**
+   * Get outPoint
+   *
+   * @return {Buffer}
+   */
+  getOutPoint() {
+    return this.outPoint;
+  }
+
+  /**
+   * Create identifier
+   *
+   * @returns {Identifier}
+   */
+  createIdentifier() {
+    return new Identifier(
+      hash(this.getOutPoint()),
+    );
+  }
+
+  /**
+   * Get plain object representation
+   *
+   * @returns {RawChainAssetLockProof}
+   */
+  toObject() {
+    return {
+      type: this.getType(),
+      height: this.getHeight(),
+      outPoint: this.getOutPoint(),
+    };
+  }
+
+  /**
+   * Get JSON representation
+   *
+   * @returns {JsonChainAssetLockProof}
+   */
+  toJSON() {
+    return {
+      type: this.getType(),
+      height: this.getHeight(),
+      outPoint: this.getOutPoint().toString('hex'),
+    };
+  }
+}
+
+/**
+ * @typedef {Object} RawChainAssetLockProof
+ * @property {number} type
+ * @property {number} height
+ * @property {Buffer} outPoint
+ */
+
+/**
+ * @typedef {Object} JsonChainAssetLockProof
+ * @property {number} type
+ * @property {number} height
+ * @property {string} outPoint
+ */
+
+module.exports = ChainAssetLockProof;