Identity v10

packages/dapi/lib/externalApis/drive/DriveClient.js

@@ -154,24 +154,6 @@ class DriveClient {
     );
   }
 
-  /**
-   * Fetch serialized identity ids by it's public key hashes
-   *
-   * @param {Buffer[]} publicKeyHashes
-   * @param {boolean} prove - include proofs into the response
-   *
-   * @return {Promise<Buffer[]>}
-   */
-  async fetchIdentityIdsByPublicKeyHashes(publicKeyHashes, prove) {
-    return this.request(
-      '/identities/by-public-key-hash/id',
-      {
-        publicKeyHashes,
-      },
-      prove,
-    );
-  }
-
   /**
    *  Fetch proofs by ids
    *

packages/dapi/test/unit/externalApis/drive/DriveClient.spec.js

@@ -5,7 +5,6 @@ const cbor = require('cbor');
 const chaiAsPromised = require('chai-as-promised');
 const dirtyChai = require('dirty-chai');
 
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
 const getIdentityFixture = require('@dashevo/dpp/lib/test/fixtures/getIdentityFixture');
 const InvalidArgumentGrpcError = require('@dashevo/grpc-common/lib/server/error/InvalidArgumentGrpcError');
 const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
@@ -191,33 +190,6 @@ describe('DriveClient', () => {
     });
   });
 
-  describe('#fetchIdentityIdsByPublicKeyHashes', () => {
-    it('Should call \'fetchIdentityIdsByPublicKeyHashes\' RPC with the given parameters', async () => {
-      const drive = new DriveClient({ host: '127.0.0.1', port: 3000 });
-
-      const identityId = generateRandomIdentifier();
-      const publicKeyHashes = [Buffer.alloc(1)];
-      const proof = Buffer.from('proof');
-      const buffer = cbor.encode({ data: [identityId], proof });
-
-      sinon.stub(drive.client, 'request')
-        .resolves({
-          result: {
-            response: { code: 0, value: buffer },
-          },
-        });
-
-      const result = await drive.fetchIdentityIdsByPublicKeyHashes(publicKeyHashes, true);
-
-      expect(drive.client.request).to.have.been.calledOnceWithExactly('abci_query', {
-        path: '/identities/by-public-key-hash/id',
-        data: cbor.encode({ publicKeyHashes }).toString('hex'),
-        prove: true,
-      });
-      expect(result).to.be.deep.equal(buffer);
-    });
-  });
-
   describe('#fetchProofs', () => {
     it('should call \'fetchProofs\' RPC with the given parameters', async () => {
       const drive = new DriveClient({ host: '127.0.0.1', port: 3000 });

packages/js-dpp/lib/StateRepositoryInterface.js

@@ -10,7 +10,7 @@
  * @method
  * @name StateRepository#fetchDataContract
  * @param {Identifier} id
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<DataContract|null>}
  */
 
@@ -21,7 +21,7 @@
  * @method
  * @name StateRepository#createDataContract
  * @param {DataContract} dataContract
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -32,7 +32,7 @@
  * @method
  * @name StateRepository#updateDataContract
  * @param {DataContract} dataContract
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -45,7 +45,7 @@
  * @param {Identifier} contractId
  * @param {string} type
  * @param {{ where: Object }} options
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<Document[]>}
  */
 
@@ -56,7 +56,7 @@
  * @method
  * @name StateRepository#createDocument
  * @param {Document} document
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -67,7 +67,7 @@
  * @method
  * @name StateRepository#updateDocument
  * @param {Document} document
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -80,7 +80,7 @@
  * @param {DataContract} dataContract
  * @param {string} type
  * @param {Identifier} id
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -91,7 +91,7 @@
  * @method
  * @name StateRepository#fetchTransaction
  * @param {string} id
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<Object|null>}
  */
 
@@ -102,53 +102,110 @@
  * @method
  * @name StateRepository#fetchIdentity
  * @param {Identifier} id
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<Identity|null>}
  */
 
 /**
- * Store identity
+ * Create identity
  *
  * @async
  * @method
  * @name StateRepository#createIdentity
  * @param {Identity} identity
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
 /**
- * Store identity
+ * Add keys to identity
  *
  * @async
  * @method
- * @name StateRepository#updateIdentity
- * @param {Identity} identity
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @name StateRepository#addKeysToIdentity
+ * @param {Identifier} identityId
+ * @param {IdentityPublicKey[]} keys
+ * @param {StateTransitionExecutionContext} [executionContext]
+ * @returns {Promise<void>}
+ */
+
+/**
+ * Disable identity keys
+ *
+ * @async
+ * @method
+ * @name StateRepository#disableIdentityKeys
+ * @param {Identifier} identityId
+ * @param {number[]} keyIds
+ * @param {number} disableAt
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
 /**
- * Store public keys hashes and identity id pair
+ * Update identity revision
+ *
+ * @async
+ * @method
+ * @name StateRepository#updateIdentityRevision
+ * @param {Identifier} identityId
+ * @param {number} revision
+ * @param {StateTransitionExecutionContext} [executionContext]
+ * @returns {Promise<void>}
+ */
+
+/**
+ * Fetch identity balance by identity ID
+ *
+ * @async
+ * @method
+ * @name StateRepository#fetchIdentityBalance
+ * @param {Identifier} id
+ * @param {StateTransitionExecutionContext} [executionContext]
+ * @returns {Promise<number|null>}
+ */
+
+/**
+ * Fetch identity balance including debt by identity ID
+ *
+ * @async
+ * @method
+ * @name StateRepository#fetchIdentityBalanceWithDebt
+ * @param {Identifier} id
+ * @param {StateTransitionExecutionContext} [executionContext]
+ * @returns {Promise<number|null>} - Balance can be negative in case of debt present
+ */
+
+/**
+ * Add to identity balance
  *
  * @async
  * @method
- * @name StateRepository#storeIdentityPublicKeyHashes
+ * @name StateRepository#addToIdentityBalance
  * @param {Identifier} identityId
- * @param {Buffer[]} publicKeyHashes
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {number} amount
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
 /**
- * Fetch identity ids by public keys hashes
+ * Add to system credits
  *
  * @async
  * @method
- * @name StateRepository#fetchIdentityIdsByPublicKeyHashes
- * @param {Buffer[]} publicKeyHashes
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
- * @returns {Promise<Array<Identifier|null>>}
+ * @name StateRepository#addToSystemCredits
+ * @param {number} amount
+ * @param {StateTransitionExecutionContext} [executionContext]
+ * @returns {Promise<void>}
+ */
+
+/**
+ * Fetch the latest platform block time
+ *
+ * @async
+ * @method
+ * @name StateRepository#fetchLatestPlatformBlockTime
+ * @returns {Promise<protobuf.Timestamp>}
  */
 
 /**
@@ -176,7 +233,7 @@
  * @method
  * @name StateRepository#verifyInstantLock
  * @param {InstantLock} instantLock
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<boolean>}
  */
 
@@ -187,7 +244,7 @@
  * @method
  * @name StateRepository#isAssetLockTransactionOutPointAlreadyUsed
  * @param {Buffer} outPointBuffer
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<boolean>}
  */
 
@@ -198,7 +255,7 @@
  * @method
  * @name StateRepository#markAssetLockTransactionOutPointAsUsed
  * @param {Buffer} outPointBuffer
- * @param {StateTransitionExecutionContext} [StateTransitionExecutionContext]
+ * @param {StateTransitionExecutionContext} [executionContext]
  * @returns {Promise<void>}
  */
 
@@ -219,14 +276,3 @@
  * @name StateRepository#fetchLatestPlatformBlockTime
  * @returns {Promise<number>}
  */
-
-/**
- * Calculates storage fee to epochs distribution amount and leftovers
- *
- * @async
- * @method
- * @name StateRepository#calculateStorageFeeDistributionAmountAndLeftovers
- * @param {number} storageFee
- * @param {number} startEpochIndex
- * @returns {Promise<[number, number]>}
- */

packages/js-dpp/lib/dataTrigger/dashpayDataTriggers/createContactRequestDataTrigger.js

@@ -64,12 +64,12 @@ async function createContactRequestDataTrigger(documentTransition, context) {
   }
 
   // toUserId identity exists
-  const identity = await stateRepository.fetchIdentity(
+  const balance = await stateRepository.fetchIdentityBalance(
     toUserId,
     context.getStateTransitionExecutionContext(),
   );
 
-  if (!isDryRun && identity === null) {
+  if (!isDryRun && balance === null) {
     const error = new DataTriggerConditionError(
       context.getDataContract()
         .getId()

packages/js-dpp/lib/identity/stateTransition/IdentityCreateTransition/applyIdentityCreateTransitionFactory.js

@@ -42,15 +42,7 @@ function applyIdentityCreateTransitionFactory(
 
     await stateRepository.createIdentity(identity, executionContext);
 
-    const publicKeyHashes = identity
-      .getPublicKeys()
-      .map((publicKey) => publicKey.hash());
-
-    await stateRepository.storeIdentityPublicKeyHashes(
-      identity.getId(),
-      publicKeyHashes,
-      executionContext,
-    );
+    await stateRepository.addToSystemCredits(creditsAmount, executionContext);
 
     const outPoint = stateTransition.getAssetLockProof().getOutPoint();
 

packages/js-dpp/lib/identity/stateTransition/IdentityCreateTransition/validation/state/validateIdentityCreateTransitionStateFactory.js

@@ -29,13 +29,14 @@ function validateIdentityCreateTransitionStateFactory(
     // Check if identity with such id already exists
     const executionContext = stateTransition.getExecutionContext();
     const identityId = stateTransition.getIdentityId();
-    const identity = await stateRepository.fetchIdentity(identityId, executionContext);
+
+    const balance = await stateRepository.fetchIdentityBalance(identityId, executionContext);
 
     if (executionContext.isDryRun()) {
       return result;
     }
 
-    if (identity) {
+    if (balance !== null) {
       result.addError(
         new IdentityAlreadyExistsError(identityId.toBuffer()),
       );

packages/js-dpp/lib/identity/stateTransition/IdentityTopUpTransition/applyIdentityTopUpTransitionFactory.js

@@ -1,5 +1,4 @@
 const { convertSatoshiToCredits } = require('../../creditsConverter');
-const getBiggestPossibleIdentity = require('../../getBiggestPossibleIdentity');
 
 /**
  * @param {StateRepository} stateRepository
@@ -34,15 +33,9 @@ function applyIdentityTopUpTransitionFactory(
 
     const identityId = stateTransition.getIdentityId();
 
-    let identity = await stateRepository.fetchIdentity(identityId, executionContext);
+    await stateRepository.addToIdentityBalance(identityId, creditsAmount, executionContext);
 
-    if (executionContext.isDryRun()) {
-      identity = getBiggestPossibleIdentity();
-    }
-
-    identity.increaseBalance(creditsAmount);
-
-    await stateRepository.updateIdentity(identity, executionContext);
+    await stateRepository.addToSystemCredits(creditsAmount, executionContext);
 
     await stateRepository.markAssetLockTransactionOutPointAsUsed(outPoint, executionContext);
   }