feat!: add more information to proofs

.github/workflows/.env

@@ -1,4 +1,4 @@
-#DRIVE_BRANCH=
+DRIVE_BRANCH=feat/additional-info-for-proofs
 DASHMATE_BRANCH=v0.20-dev
 #TEST_SUITE_BRANCH=
 #SDK_BRANCH=

lib/externalApis/drive/DriveClient.js

@@ -22,7 +22,7 @@ class DriveClient {
    * @param {Object} data
    * @param {boolean} prove
    *
-   * @return {Promise<{ data: Buffer, [proof]: {rootTreeProof: Buffer, storeTreeProof: Buffer}}>}
+   * @return {Promise<Buffer>}
    */
   async request(path, data = {}, prove = false) {
     const encodedData = cbor.encode(data);
@@ -53,14 +53,29 @@ class DriveClient {
 
     if (response.code === undefined || response.code === 0) {
       // no errors found return the serialized response value
-      return cbor.decode(Buffer.from(response.value, 'base64'));
+      return Buffer.from(response.value, 'base64');
     }
 
     const { error: abciError } = JSON.parse(response.log);
 
     throw new AbciResponseError(response.code, abciError);
   }
 
+  /**
+   * Makes request to Drive and handle CBOR'ed response
+   *
+   * @param {string} path
+   * @param {Object} data
+   * @param {boolean} prove
+   *
+   * @return {Promise<{ data: Buffer, [proof]: {rootTreeProof: Buffer, storeTreeProof: Buffer}}>}
+   */
+  async requestCbor(path, data = {}, prove = false) {
+    const responseBuffer = await this.request(path, data, prove);
+
+    return cbor.decode(responseBuffer);
+  }
+
   /**
    * Fetch serialized data contract
    *
@@ -170,7 +185,7 @@ class DriveClient {
    * @return {Promise<{data: Buffer}>}
    */
   async fetchProofs({ documentIds, identityIds, dataContractIds }) {
-    return this.request(
+    return this.requestCbor(
       '/proofs',
       {
         documentIds,

lib/grpcServer/handlers/platform/getDataContractHandlerFactory.js

@@ -9,7 +9,6 @@ const {
 const {
   v0: {
     GetDataContractResponse,
-    Proof,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -38,31 +37,18 @@ function getDataContractHandlerFactory(driveClient, handleAbciResponseError) {
       throw new InvalidArgumentGrpcError('id is not specified');
     }
 
-    let dataContractBuffer;
-    let proofObject;
+    let dataContractResponseBuffer;
     try {
-      ({ data: dataContractBuffer, proof: proofObject } = await driveClient
-        .fetchDataContract(id, prove));
+      dataContractResponseBuffer = await driveClient
+        .fetchDataContract(id, prove);
     } catch (e) {
       if (e instanceof AbciResponseError) {
         handleAbciResponseError(e);
       }
       throw e;
     }
 
-    const response = new GetDataContractResponse();
-
-    response.setDataContract(dataContractBuffer);
-
-    if (prove === true) {
-      const proof = new Proof();
-      proof.setRootTreeProof(proofObject.rootTreeProof);
-      proof.setStoreTreeProof(proofObject.storeTreeProof);
-
-      response.setProof(proof);
-    }
-
-    return response;
+    return GetDataContractResponse.deserializeBinary(dataContractResponseBuffer);
   }
 
   return getDataContractHandler;

lib/grpcServer/handlers/platform/getDocumentsHandlerFactory.js

@@ -11,7 +11,6 @@ const {
 const {
   v0: {
     GetDocumentsResponse,
-    Proof,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -111,32 +110,19 @@ function getDocumentsHandlerFactory(driveClient, handleAbciResponseError) {
 
     const prove = request.getProve();
 
-    let documentBuffers;
-    let proofObject;
+    let documentResponseBuffer;
     try {
-      ({ data: documentBuffers, proof: proofObject } = await driveClient.fetchDocuments(
+      documentResponseBuffer = await driveClient.fetchDocuments(
         dataContractId, documentType, options, prove,
-      ));
+      );
     } catch (e) {
       if (e instanceof AbciResponseError) {
         handleAbciResponseError(e);
       }
       throw e;
     }
 
-    const response = new GetDocumentsResponse();
-
-    response.setDocumentsList(documentBuffers);
-
-    if (prove === true) {
-      const proof = new Proof();
-      proof.setRootTreeProof(proofObject.rootTreeProof);
-      proof.setStoreTreeProof(proofObject.storeTreeProof);
-
-      response.setProof(proof);
-    }
-
-    return response;
+    return GetDocumentsResponse.deserializeBinary(documentResponseBuffer);
   }
 
   return getDocumentsHandler;

lib/grpcServer/handlers/platform/getIdentitiesByPublicKeyHashesHandlerFactory.js

@@ -9,7 +9,6 @@ const {
 const {
   v0: {
     GetIdentitiesByPublicKeyHashesResponse,
-    Proof,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -40,33 +39,18 @@ function getIdentitiesByPublicKeyHashesHandlerFactory(
 
     const prove = request.getProve();
 
-    let identities;
-    let proofObject;
+    let identitiesResponseBuffer;
     try {
-      ({ data: identities, proof: proofObject } = await driveClient
-        .fetchIdentitiesByPublicKeyHashes(publicKeyHashes, prove));
+      identitiesResponseBuffer = await driveClient
+        .fetchIdentitiesByPublicKeyHashes(publicKeyHashes, prove);
     } catch (e) {
       if (e instanceof AbciResponseError) {
         handleAbciResponseError(e);
       }
       throw e;
     }
 
-    const response = new GetIdentitiesByPublicKeyHashesResponse();
-
-    response.setIdentitiesList(
-      identities,
-    );
-
-    if (prove === true) {
-      const proof = new Proof();
-      proof.setRootTreeProof(proofObject.rootTreeProof);
-      proof.setStoreTreeProof(proofObject.storeTreeProof);
-
-      response.setProof(proof);
-    }
-
-    return response;
+    return GetIdentitiesByPublicKeyHashesResponse.deserializeBinary(identitiesResponseBuffer);
   }
 
   return getIdentitiesByPublicKeyHashesHandler;

lib/grpcServer/handlers/platform/getIdentityHandlerFactory.js

@@ -9,7 +9,6 @@ const {
 const {
   v0: {
     GetIdentityResponse,
-    Proof,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -40,32 +39,19 @@ function getIdentityHandlerFactory(driveClient, handleAbciResponseError) {
 
     const prove = request.getProve();
 
-    let identityBuffer;
-    let proofObject;
+    let identityResponseBuffer;
 
     try {
-      ({ data: identityBuffer, proof: proofObject } = await driveClient
-        .fetchIdentity(id, prove));
+      identityResponseBuffer = await driveClient
+        .fetchIdentity(id, prove);
     } catch (e) {
       if (e instanceof AbciResponseError) {
         handleAbciResponseError(e);
       }
       throw e;
     }
 
-    const response = new GetIdentityResponse();
-
-    response.setIdentity(identityBuffer);
-
-    if (prove === true) {
-      const proof = new Proof();
-      proof.setRootTreeProof(proofObject.rootTreeProof);
-      proof.setStoreTreeProof(proofObject.storeTreeProof);
-
-      response.setProof(proof);
-    }
-
-    return response;
+    return GetIdentityResponse.deserializeBinary(identityResponseBuffer);
   }
 
   return getIdentityHandler;

lib/grpcServer/handlers/platform/getIdentityIdsByPublicKeyHashesHandlerFactory.js

@@ -9,7 +9,6 @@ const {
 const {
   v0: {
     GetIdentityIdsByPublicKeyHashesResponse,
-    Proof,
   },
 } = require('@dashevo/dapi-grpc');
 
@@ -40,37 +39,22 @@ function getIdentityIdsByPublicKeyHashesHandlerFactory(
 
     const prove = request.getProve();
 
-    let identityIds;
-    let proofObject;
+    let identityIdsResponseBuffer;
 
     try {
-      ({ data: identityIds, proof: proofObject } = await driveClient
+      identityIdsResponseBuffer = await driveClient
         .fetchIdentityIdsByPublicKeyHashes(
           publicKeyHashes,
           prove,
-        ));
+        );
     } catch (e) {
       if (e instanceof AbciResponseError) {
         handleAbciResponseError(e);
       }
       throw e;
     }
 
-    const response = new GetIdentityIdsByPublicKeyHashesResponse();
-
-    response.setIdentityIdsList(
-      identityIds,
-    );
-
-    if (prove === true) {
-      const proof = new Proof();
-      proof.setRootTreeProof(proofObject.rootTreeProof);
-      proof.setStoreTreeProof(proofObject.storeTreeProof);
-
-      response.setProof(proof);
-    }
-
-    return response;
+    return GetIdentityIdsByPublicKeyHashesResponse.deserializeBinary(identityIdsResponseBuffer);
   }
 
   return getIdentityIdsByPublicKeyHashesHandler;

lib/grpcServer/handlers/platform/waitForStateTransitionResultHandlerFactory.js

@@ -117,6 +117,8 @@ function waitForStateTransitionResultHandlerFactory(
 
       proof.setRootTreeProof(proofObject.rootTreeProof);
       proof.setStoreTreeProof(proofObject.storeTreeProof);
+      proof.setSignatureLlmqHash(proofObject.signatureLlmqHash);
+      proof.setSignature(proofObject.signature);
 
       response.setProof(proof);
     }

package.json

@@ -27,7 +27,7 @@
     "all": true
   },
   "dependencies": {
-    "@dashevo/dapi-grpc": "~0.19.0",
+    "@dashevo/dapi-grpc": "~0.20.0-dev.2",
     "@dashevo/dashcore-lib": "~0.19.23",
     "@dashevo/dashd-rpc": "^2.0.2",
     "@dashevo/dpp": "~0.19.1",

test/unit/externalApis/drive/DriveClient.js

@@ -103,10 +103,7 @@ describe('DriveClient', () => {
         data: cbor.encode({ id: contractId }).toString('hex'), // cbor encoded empty object
         prove: 'true',
       });
-      expect(result).to.be.deep.equal({
-        data,
-        proof,
-      });
+      expect(result).to.be.deep.equal(buffer);
     });
   });
 
@@ -138,10 +135,7 @@ describe('DriveClient', () => {
         data: cbor.encode({ ...options, contractId, type }).toString('hex'), // cbor encoded empty object
         prove: 'true',
       });
-      expect(result).to.be.deep.equal({
-        data,
-        proof,
-      });
+      expect(result).to.be.deep.equal(buffer);
     });
   });
 
@@ -166,7 +160,7 @@ describe('DriveClient', () => {
         path: '/identities',
         data: cbor.encode({ id: identityId }).toString('hex'), // cbor encoded empty object
       });
-      expect(result).to.be.deep.equal({ data });
+      expect(result).to.be.deep.equal(buffer);
     });
   });
 
@@ -194,10 +188,7 @@ describe('DriveClient', () => {
         data: cbor.encode({ publicKeyHashes }).toString('hex'),
         prove: 'true',
       });
-      expect(result).to.be.deep.equal({
-        data: [identity],
-        proof,
-      });
+      expect(result).to.be.deep.equal(buffer);
     });
   });
 
@@ -224,10 +215,7 @@ describe('DriveClient', () => {
         data: cbor.encode({ publicKeyHashes }).toString('hex'),
         prove: 'true',
       });
-      expect(result).to.be.deep.equal({
-        data: [identityId],
-        proof,
-      });
+      expect(result).to.be.deep.equal(buffer);
     });
   });