feat: implement getConsensusParams method

.github/workflows/.env

@@ -1,4 +1,4 @@
-# DRIVE_BRANCH=
-# DASHMATE_BRANCH=
-TEST_SUITE_BRANCH=fix-document-test
+DRIVE_BRANCH=update_consensus_params_feature_flag
+DASHMATE_BRANCH=v0.21-dev
+TEST_SUITE_BRANCH=feature-flags
 # SDK_BRANCH=

.gitignore

@@ -11,3 +11,4 @@ test/rpc
 coverage/
 dapidb/
 /.env
+docker/cache

lib/externalApis/tenderdash/getConsensusParamsFactory.js

@@ -0,0 +1,51 @@
+const RPCError = require('../../rpcServer/RPCError');
+
+/**
+ * @param {RpcClient} rpcClient
+ * @return {getConsensusParams}
+ */
+function getConsensusParamsFactory(rpcClient) {
+  /**
+   * @typedef getConsensusParams
+   * @param {number} [height]
+   * @returns {Promise<{
+   * block: {
+   *   max_bytes: string,
+   *   max_gas: string,
+   *   time_iota_ms: string
+   *  },
+   *  evidence: {
+   *    max_age_num_blocks: string,
+   *    max_age_duration: string,
+   *    max_bytes: string,
+   *  }
+   *  }>}
+   */
+  async function getConsensusParams(height = undefined) {
+    const params = {};
+
+    if (height !== undefined) {
+      params.height = height;
+    }
+
+    const { result, error } = await rpcClient.request('consensus_params', params);
+
+    // Handle JSON RPC error
+    if (error) {
+      throw new RPCError(
+        error.code || -32602,
+        error.message || 'Internal error',
+        error.data,
+      );
+    }
+
+    return {
+      block: result.consensus_params.block,
+      evidence: result.consensus_params.evidence,
+    };
+  }
+
+  return getConsensusParams;
+}
+
+module.exports = getConsensusParamsFactory;

lib/grpcServer/handlers/platform/getConsensusParamsHandlerFactory.js

@@ -0,0 +1,75 @@
+const InvalidArgumentGrpcError = require('@dashevo/grpc-common/lib/server/error/InvalidArgumentGrpcError');
+
+const {
+  server: {
+    error: {
+      InternalGrpcError,
+    },
+  },
+} = require('@dashevo/grpc-common');
+
+const {
+  v0: {
+    GetConsensusParamsResponse,
+    ConsensusParamsBlock,
+    ConsensusParamsEvidence,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const RPCError = require('../../../rpcServer/RPCError');
+
+/**
+ *
+ * @param {getConsensusParams} getConsensusParams
+ * @returns {getConsensusParamsHandler}
+ */
+function getConsensusParamsHandlerFactory(getConsensusParams) {
+  /**
+   * @typedef getConsensusParamsHandler
+   * @param {Object} call
+   * @returns {Promise<>}
+   */
+  async function getConsensusParamsHandler(call) {
+    const { request } = call;
+
+    const prove = request.getProve();
+
+    if (prove) {
+      throw new InvalidArgumentGrpcError('Prove is not implemented yet');
+    }
+
+    let consensusParams;
+
+    try {
+      consensusParams = await getConsensusParams();
+    } catch (e) {
+      if (e instanceof RPCError) {
+        throw new InternalGrpcError(e);
+      }
+
+      throw e;
+    }
+
+    const response = new GetConsensusParamsResponse();
+
+    const block = new ConsensusParamsBlock();
+    block.setMaxBytes(consensusParams.block.max_bytes);
+    block.setMaxGas(consensusParams.block.max_gas);
+    block.setTimeIotaMs(consensusParams.block.time_iota_ms);
+
+    response.setBlock(block);
+
+    const evidence = new ConsensusParamsEvidence();
+    evidence.setMaxAgeNumBlocks(consensusParams.evidence.max_age_num_blocks);
+    evidence.setMaxAgeDuration(consensusParams.evidence.max_age_duration);
+    evidence.setMaxBytes(consensusParams.evidence.max_bytes);
+
+    response.setEvidence(evidence);
+
+    return response;
+  }
+
+  return getConsensusParamsHandler;
+}
+
+module.exports = getConsensusParamsHandlerFactory;

lib/grpcServer/handlers/platform/platformHandlersFactory.js

@@ -22,6 +22,7 @@ const {
     GetIdentitiesByPublicKeyHashesRequest,
     GetIdentityIdsByPublicKeyHashesRequest,
     WaitForStateTransitionResultRequest,
+    GetConsensusParamsRequest,
     pbjs: {
       BroadcastStateTransitionRequest: PBJSBroadcastStateTransitionRequest,
       BroadcastStateTransitionResponse: PBJSBroadcastStateTransitionResponse,
@@ -37,6 +38,8 @@ const {
       GetIdentityIdsByPublicKeyHashesRequest: PBJSGetIdentityIdsByPublicKeyHashesRequest,
       WaitForStateTransitionResultRequest: PBJSWaitForStateTransitionResultRequest,
       WaitForStateTransitionResultResponse: PBJSWaitForStateTransitionResultResponse,
+      GetConsensusParamsRequest: PBJSGetConsensusParamsRequest,
+      GetConsensusParamsResponse: PBJSGetConsensusParamsResponse,
     },
   },
 } = require('@dashevo/dapi-grpc');
@@ -66,12 +69,16 @@ const getIdentityIdsByPublicKeyHashesHandlerFactory = require(
 const waitForStateTransitionResultHandlerFactory = require(
   './waitForStateTransitionResultHandlerFactory',
 );
+const getConsensusParamsHandlerFactory = require(
+  './getConsensusParamsHandlerFactory',
+);
 
 const fetchProofForStateTransitionFactory = require('../../../externalApis/drive/fetchProofForStateTransitionFactory');
 const waitForTransactionToBeProvableFactory = require('../../../externalApis/tenderdash/waitForTransactionToBeProvable/waitForTransactionToBeProvableFactory');
 const waitForTransactionResult = require('../../../externalApis/tenderdash/waitForTransactionToBeProvable/waitForTransactionResult');
 const waitForHeightFactory = require('../../../externalApis/tenderdash/waitForHeightFactory');
 const getExistingTransactionResultFactory = require('../../../externalApis/tenderdash/waitForTransactionToBeProvable/getExistingTransactionResult');
+const getConsensusParamsFactory = require('../../../externalApis/tenderdash/getConsensusParamsFactory');
 
 /**
  * @param {jaysonClient} rpcClient
@@ -220,6 +227,21 @@ function platformHandlersFactory(
     wrapInErrorHandler(waitForStateTransitionResultHandler),
   );
 
+  // get Consensus Params
+  const getConsensusParams = getConsensusParamsFactory(rpcClient);
+  const getConsensusParamsHandler = getConsensusParamsHandlerFactory(getConsensusParams);
+
+  const wrappedGetConsensusParams = jsonToProtobufHandlerWrapper(
+    jsonToProtobufFactory(
+      GetConsensusParamsRequest,
+      PBJSGetConsensusParamsRequest,
+    ),
+    protobufToJsonFactory(
+      PBJSGetConsensusParamsResponse,
+    ),
+    wrapInErrorHandler(getConsensusParamsHandler),
+  );
+
   return {
     broadcastStateTransition: wrappedBroadcastStateTransition,
     getIdentity: wrappedGetIdentity,
@@ -228,6 +250,7 @@ function platformHandlersFactory(
     getIdentitiesByPublicKeyHashes: wrappedGetIdentitiesByPublicKeyHashes,
     getIdentityIdsByPublicKeyHashes: wrappedGetIdentityIdsByPublicKeyHashes,
     waitForStateTransitionResult: wrappedWaitForStateTransitionResult,
+    getConsensusParams: wrappedGetConsensusParams,
   };
 }