feat: create Identity factory accepts locked out point and public keys

lib/identity/Identity.js

@@ -126,6 +126,27 @@ class Identity {
 
     return this.balance;
   }
+
+  /**
+   * Set locked out point
+   *
+   * @param {Buffer} lockedOutPoint
+   * @return {Identity}
+   */
+  setLockedOutPoint(lockedOutPoint) {
+    this.lockedOutPoint = lockedOutPoint;
+
+    return this;
+  }
+
+  /**
+   * Get locked out point
+   *
+   * @return {Buffer}
+   */
+  getLockedOutPoint() {
+    return this.lockedOutPoint;
+  }
 }
 
 module.exports = Identity;

lib/identity/IdentityFacade.js

@@ -24,12 +24,12 @@ class IdentityFacade {
   /**
    * Create Identity
    *
-   * @param {string} id
-   * @param {IdentityPublicKey[]} [publicKeys]
+   * @param {Buffer} lockedOutPoint
+   * @param {PublicKey[]} [publicKeys]
    * @return {Identity}
    */
-  create(id, publicKeys = []) {
-    return this.factory.create(id, publicKeys);
+  create(lockedOutPoint, publicKeys = []) {
+    return this.factory.create(lockedOutPoint, publicKeys);
   }
 
   /**

lib/identity/IdentityFactory.js

@@ -1,7 +1,13 @@
+const bs58 = require('bs58');
+
+const hash = require('../util/hash');
+
 const Identity = require('./Identity');
 
 const { decode } = require('../util/serializer');
 
+const IdentityPublicKey = require('./IdentityPublicKey');
+
 const InvalidIdentityError = require('./errors/InvalidIdentityError');
 const SerializedObjectParsingError = require('../errors/SerializedObjectParsingError');
 
@@ -16,18 +22,30 @@ class IdentityFactory {
   /**
    * Create Identity
    *
-   * @param {string} id
-   * @param {IdentityPublicKey[]} [publicKeys]
+   * @param {Buffer} lockedOutPoint
+   * @param {PublicKey[]} [publicKeys]
    * @return {Identity}
    */
-  create(id, publicKeys = []) {
-    const balance = 0;
+  create(lockedOutPoint, publicKeys = []) {
+    const id = bs58.encode(
+      hash(lockedOutPoint),
+    );
 
-    return new Identity({
+    const identity = new Identity({
       id,
-      balance,
-      publicKeys: publicKeys.map((p) => p.toJSON()),
+      balance: 0,
+      publicKeys: publicKeys.map((publicKey, i) => ({
+        id: i + 1,
+        type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+        data: publicKey.toBuffer()
+          .toString('base64'),
+        isEnabled: true,
+      })),
     });
+
+    identity.setLockedOutPoint(lockedOutPoint);
+
+    return identity;
   }
 
   /**

test/integration/identity/IdentityFacade.spec.js

@@ -1,3 +1,10 @@
+const bs58 = require('bs58');
+const crypto = require('crypto');
+
+const { PublicKey } = require('@dashevo/dashcore-lib');
+
+const hash = require('../../../lib/util/hash');
+
 const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
 
 const Identity = require('../../../lib/identity/Identity');
@@ -28,16 +35,27 @@ describe('IdentityFacade', () => {
 
   describe('#create', () => {
     it('should create Identity', () => {
-      identity.balance = 0;
+      const lockedOutPoint = crypto.randomBytes(64);
+
+      identity.id = bs58.encode(
+        hash(lockedOutPoint),
+      );
+
+      identity.setBalance(0);
+
+      const publicKeys = identity.getPublicKeys().map((identityPublicKey) => {
+        const publicKeyData = Buffer.from(identityPublicKey.getData(), 'base64');
+
+        return new PublicKey(publicKeyData);
+      });
 
       const result = dpp.identity.create(
-        identity.getId(),
-        identity.getPublicKeys(),
+        lockedOutPoint,
+        publicKeys,
       );
 
       expect(result).to.be.an.instanceOf(Identity);
-
-      expect(result).to.deep.equal(identity);
+      expect(result.toJSON()).to.deep.equal(identity.toJSON());
     });
   });
 

test/unit/identity/IdentityFactory.spec.js

@@ -1,4 +1,10 @@
 const rewiremock = require('rewiremock/node');
+const bs58 = require('bs58');
+const crypto = require('crypto');
+
+const { PublicKey } = require('@dashevo/dashcore-lib');
+
+const hash = require('../../../lib/util/hash');
 
 const Identity = require('../../../lib/identity/Identity');
 
@@ -45,16 +51,28 @@ describe('IdentityFactory', () => {
   });
 
   describe('#create', () => {
-    it('should create Identity with specified id, type and public keys', () => {
-      identity.balance = 0;
+    it('should create Identity from transaction out point and public keys', () => {
+      const lockedOutPoint = crypto.randomBytes(64);
+
+      identity.id = bs58.encode(
+        hash(lockedOutPoint),
+      );
+
+      identity.setBalance(0);
+
+      const publicKeys = identity.getPublicKeys().map((identityPublicKey) => {
+        const publicKeyData = Buffer.from(identityPublicKey.getData(), 'base64');
+
+        return new PublicKey(publicKeyData);
+      });
 
       const result = factory.create(
-        identity.getId(),
-        identity.getPublicKeys(),
+        lockedOutPoint,
+        publicKeys,
       );
 
       expect(result).to.be.an.instanceOf(Identity);
-      expect(result).to.deep.equal(identity);
+      expect(result.toJSON()).to.deep.equal(identity.toJSON());
     });
   });