feat: get identity by public key endpoints

lib/externalApis/drive/DriveStateRepository.js

@@ -109,6 +109,26 @@ class DriveStateRepository {
   async fetchPublicKeyIdentityId(publicKeyHash) {
     return this.request(`/identities/by-first-public-key/${publicKeyHash}/id`);
   }
+
+  /**
+   * Fetch serialized identity by public key hash
+   *
+   * @param {string} publicKeyHash
+   * @return {Promise<Buffer>}
+   */
+  async fetchIdentityByFirstPublicKey(publicKeyHash) {
+    return this.request(`/identities/by-first-public-key/${publicKeyHash}`);
+  }
+
+  /**
+   * Fetch identity id by public key hash
+   *
+   * @param {string} publicKeyHash
+   * @return {Promise<string>}
+   */
+  async fetchIdentityIdByFirstPublicKey(publicKeyHash) {
+    return this.request(`/identities/by-first-public-key/${publicKeyHash}/id`);
+  }
 }
 
 module.exports = DriveStateRepository;

lib/grpcServer/handlers/platform/getIdentityByFirstPublicKeyHandlerFactory.js

@@ -0,0 +1,60 @@
+const {
+  server: {
+    error: {
+      InvalidArgumentGrpcError,
+    },
+  },
+} = require('@dashevo/grpc-common');
+
+const {
+  GetIdentityByFirstPublicKeyResponse,
+} = require('@dashevo/dapi-grpc');
+
+const AbciResponseError = require('../../../errors/AbciResponseError');
+
+/**
+ *
+ * @param {DriveStateRepository} driveStateRepository
+ * @param {handleAbciResponseError} handleAbciResponseError
+ * @return {getIdentityByFirstPublicKeyHandler}
+ */
+function getIdentityByFirstPublicKeyHandlerFactory(driveStateRepository, handleAbciResponseError) {
+  /**
+   * @typedef getIdentityByFirstPublicKeyHandler
+   * @param {Object} call
+   * @return {Promise<GetIdentityByFirstPublicKeyResponse>}
+   */
+  async function getIdentityByFirstPublicKeyHandler(call) {
+    const { request } = call;
+
+    const publicKeyHash = request.getPublicKeyHash();
+
+    if (!publicKeyHash) {
+      throw new InvalidArgumentGrpcError('Public key hash is not specified');
+    }
+
+    const publicKeyHashString = Buffer.from(publicKeyHash).toString('hex');
+
+    let identityBuffer;
+    try {
+      identityBuffer = await driveStateRepository.fetchIdentityByFirstPublicKey(
+        publicKeyHashString,
+      );
+    } catch (e) {
+      if (e instanceof AbciResponseError) {
+        handleAbciResponseError(e);
+      }
+      throw e;
+    }
+
+    const response = new GetIdentityByFirstPublicKeyResponse();
+
+    response.setIdentity(identityBuffer);
+
+    return response;
+  }
+
+  return getIdentityByFirstPublicKeyHandler;
+}
+
+module.exports = getIdentityByFirstPublicKeyHandlerFactory;

lib/grpcServer/handlers/platform/getIdentityIdByFirstPublicKeyHandlerFactory.js

@@ -0,0 +1,64 @@
+const bs58 = require('bs58');
+
+const {
+  server: {
+    error: {
+      InvalidArgumentGrpcError,
+    },
+  },
+} = require('@dashevo/grpc-common');
+
+const {
+  GetIdentityIdByFirstPublicKeyResponse,
+} = require('@dashevo/dapi-grpc');
+
+const AbciResponseError = require('../../../errors/AbciResponseError');
+
+/**
+ *
+ * @param {DriveStateRepository} driveStateRepository
+ * @param {handleAbciResponseError} handleAbciResponseError
+ * @return {getIdentityIdByFirstPublicKeyHandler}
+ */
+function getIdentityIdByFirstPublicKeyHandlerFactory(
+  driveStateRepository,
+  handleAbciResponseError,
+) {
+  /**
+   *
+   * @typedef getIdentityIdByFirstPublicKeyHandler
+   * @param {Object} call
+   * @return {Promise<GetIdentityByFirstPublicKeyResponse>}
+   */
+  async function getIdentityIdByFirstPublicKeyHandler(call) {
+    const { request } = call;
+
+    const publicKeyHash = request.getPublicKeyHash();
+
+    if (!publicKeyHash) {
+      throw new InvalidArgumentGrpcError('Public key hash is not specified');
+    }
+
+    const publicKeyHashString = Buffer.from(publicKeyHash).toString('hex');
+
+    let identityId;
+    try {
+      identityId = await driveStateRepository.fetchIdentityIdByFirstPublicKey(publicKeyHashString);
+    } catch (e) {
+      if (e instanceof AbciResponseError) {
+        handleAbciResponseError(e);
+      }
+      throw e;
+    }
+
+    const response = new GetIdentityIdByFirstPublicKeyResponse();
+
+    response.setId(bs58.encode(identityId));
+
+    return response;
+  }
+
+  return getIdentityIdByFirstPublicKeyHandler;
+}
+
+module.exports = getIdentityIdByFirstPublicKeyHandlerFactory;

lib/grpcServer/handlers/platform/platformHandlersFactory.js

@@ -18,6 +18,8 @@ const {
   GetIdentityRequest,
   GetDataContractRequest,
   GetDocumentsRequest,
+  GetIdentityByFirstPublicKeyRequest,
+  GetIdentityIdByFirstPublicKeyRequest,
   pbjs: {
     ApplyStateTransitionRequest: PBJSApplyStateTransitionRequest,
     ApplyStateTransitionResponse: PBJSApplyStateTransitionResponse,
@@ -27,6 +29,10 @@ const {
     GetDataContractResponse: PBJSGetDataContractResponse,
     GetDocumentsRequest: PBJSGetDocumentsRequest,
     GetDocumentsResponse: PBJSGetDocumentsResponse,
+    GetIdentityByFirstPublicKeyResponse: PBJSGetIdentityByFirstPublicKeyResponse,
+    GetIdentityByFirstPublicKeyRequest: PBJSGetIdentityByFirstPublicKeyRequest,
+    GetIdentityIdByFirstPublicKeyResponse: PBJSGetIdentityIdByFirstPublicKeyResponse,
+    GetIdentityIdByFirstPublicKeyRequest: PBJSGetIdentityIdByFirstPublicKeyRequest,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -46,6 +52,12 @@ const getDocumentsHandlerFactory = require(
 const getDataContractHandlerFactory = require(
   './getDataContractHandlerFactory',
 );
+const getIdentityByFirstPublicKeyHandlerFactory = require(
+  './getIdentityByFirstPublicKeyHandlerFactory',
+);
+const getIdentityIdByFirstPublicKeyHandlerFactory = require(
+  './getIdentityIdByFirstPublicKeyHandlerFactory',
+);
 
 /**
  * @param {jaysonClient} rpcClient
@@ -120,11 +132,45 @@ function platformHandlersFactory(rpcClient, driveStateRepository) {
     wrapInErrorHandler(getDataContractHandler),
   );
 
+  // getIdentityByFirstPublicKey
+  const getIdentityByFirstPublicKeyHandler = getIdentityByFirstPublicKeyHandlerFactory(
+    driveStateRepository, handleAbciResponseError,
+  );
+
+  const wrappedGetIdentityByFirstPublicKey = jsonToProtobufHandlerWrapper(
+    jsonToProtobufFactory(
+      GetIdentityByFirstPublicKeyRequest,
+      PBJSGetIdentityByFirstPublicKeyRequest,
+    ),
+    protobufToJsonFactory(
+      PBJSGetIdentityByFirstPublicKeyResponse,
+    ),
+    wrapInErrorHandler(getIdentityByFirstPublicKeyHandler),
+  );
+
+  // getIdentityIdByFirstPublicKey
+  const getIdentityIdByFirstPublicKeyHandler = getIdentityIdByFirstPublicKeyHandlerFactory(
+    driveStateRepository, handleAbciResponseError,
+  );
+
+  const wrappedGetIdentityIdByFirstPublicKey = jsonToProtobufHandlerWrapper(
+    jsonToProtobufFactory(
+      GetIdentityIdByFirstPublicKeyRequest,
+      PBJSGetIdentityIdByFirstPublicKeyRequest,
+    ),
+    protobufToJsonFactory(
+      PBJSGetIdentityIdByFirstPublicKeyResponse,
+    ),
+    wrapInErrorHandler(getIdentityIdByFirstPublicKeyHandler),
+  );
+
   return {
     applyStateTransition: wrappedApplyStateTransition,
     getIdentity: wrappedGetIdentity,
     getDocuments: wrappedGetDocuments,
     getDataContract: wrappedGetDataContract,
+    getIdentityByFirstPublicKey: wrappedGetIdentityByFirstPublicKey,
+    getIdentityIdByFirstPublicKey: wrappedGetIdentityIdByFirstPublicKey,
   };
 }
 

lib/test/bootstrap.js

@@ -53,6 +53,9 @@ if (process.env.SERVICE_IMAGE_DRIVE) {
   DriveAbciOptions.setDefaultCustomOptions({
     container: {
       image: process.env.SERVICE_IMAGE_DRIVE,
+      envs: [
+        'IDENTITY_ENABLE_LOCK_TX_ONE_BLOCK_CONFIRMATION_FALLBACK=true',
+      ],
     },
   });
 }