feat!: chain Asset Lock proof

lib/StateRepositoryInterface.js

@@ -126,25 +126,36 @@
  * @async
  * @method
  * @name StateRepository#verifyInstantLock
+ * @param {InstantLock} instantLock
  * @returns {Promise<boolean>}
  */
 
 /**
- * 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/Identity.js

@@ -163,24 +163,24 @@ class Identity {
   }
 
   /**
-   * Set asset lock
+   * Set asset lock proof
    *
-   * @param {AssetLock} assetLock
+   * @param {InstantAssetLockProof} assetLockProof
    * @return {Identity}
    */
-  setAssetLock(assetLock) {
-    this.assetLock = assetLock;
+  setAssetLockProof(assetLockProof) {
+    this.assetLockProof = assetLockProof;
 
     return this;
   }
 
   /**
-   * Get locked out point
+   * Get asset lock proof
    *
-   * @return {AssetLock}
+   * @return {InstantAssetLockProof}
    */
-  getAssetLock() {
-    return this.assetLock;
+  getAssetLockProof() {
+    return this.assetLockProof;
   }
 
   /**

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,12 @@ class IdentityFacade {
    * Create Asset Lock with proofs
    *
    * @param {InstantLock} instantLock
+   * @param {Transaction} assetLockTransaction
+   * @param {number} outputIndex
    * @returns {InstantAssetLockProof}
    */
-  createInstantAssetLockProof(instantLock) {
-    return this.factory.createInstantAssetLockProof(instantLock);
+  createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex) {
+    return this.factory.createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex);
   }
 
   /**
@@ -106,16 +104,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

@@ -8,7 +8,6 @@ const IdentityTopUpTransition = require('./stateTransitions/identityTopUpTransit
 
 const InvalidIdentityError = require('./errors/InvalidIdentityError');
 const SerializedObjectParsingError = require('../errors/SerializedObjectParsingError');
-const AssetLock = require('./stateTransitions/assetLock/AssetLock');
 const InstantAssetLockProof = require('./stateTransitions/assetLock/proof/instant/InstantAssetLockProof');
 
 class IdentityFactory {
@@ -22,22 +21,14 @@ class IdentityFactory {
   /**
    * Create Identity
    *
-   * @param {Transaction} assetLockTransaction
-   * @param {number} outputIndex
    * @param {InstantAssetLockProof} assetLockProof
    * @param {PublicKey[]} publicKeys
    * @return {Identity}
    */
-  create(assetLockTransaction, outputIndex, assetLockProof, publicKeys) {
-    const assetLock = new AssetLock({
-      transaction: assetLockTransaction.toBuffer(),
-      outputIndex,
-      proof: assetLockProof.toObject(),
-    });
-
+  create(assetLockProof, publicKeys) {
     const identity = new Identity({
       protocolVersion: Identity.PROTOCOL_VERSION,
-      id: assetLock.createIdentifier(),
+      id: assetLockProof.createIdentifier(),
       balance: 0,
       publicKeys: publicKeys.map((publicKey, i) => ({
         id: i,
@@ -47,7 +38,7 @@ class IdentityFactory {
       revision: 0,
     });
 
-    identity.setAssetLock(assetLock);
+    identity.setAssetLockProof(assetLockProof);
 
     return identity;
   }
@@ -102,11 +93,15 @@ class IdentityFactory {
    * Create Asset Lock with proofs
    *
    * @param {InstantLock} instantLock
+   * @param {Transaction} assetLockTransaction
+   * @param {number} outputIndex
    * @returns {InstantAssetLockProof}
    */
-  createInstantAssetLockProof(instantLock) {
+  createInstantAssetLockProof(instantLock, assetLockTransaction, outputIndex) {
     return new InstantAssetLockProof({
       instantLock: instantLock.toBuffer(),
+      transaction: assetLockTransaction.toBuffer(),
+      outputIndex,
     });
   }
 
@@ -119,7 +114,7 @@ class IdentityFactory {
   createIdentityCreateTransition(identity) {
     const stateTransition = new IdentityCreateTransition({
       protocolVersion: Identity.PROTOCOL_VERSION,
-      assetLock: identity.getAssetLock().toObject(),
+      assetLockProof: identity.getAssetLockProof().toObject(),
     });
 
     stateTransition.setPublicKeys(identity.getPublicKeys());
@@ -131,22 +126,14 @@ 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) {
-    const assetLock = new AssetLock({
-      transaction: assetLockTransaction.toBuffer(),
-      outputIndex,
-      proof: assetLockProof.toObject(),
-    });
-
+  createIdentityTopUpTransition(identityId, assetLockProof) {
     return new IdentityTopUpTransition({
       protocolVersion: Identity.PROTOCOL_VERSION,
       identityId,
-      assetLock: assetLock.toObject(),
+      assetLockProof: assetLockProof.toObject(),
     });
   }
 }