Bindings: Add ProtocolParameters tests

bindings/core/src/method/utils.rs

@@ -30,92 +30,72 @@ use crate::OmittedDebug;
 pub enum UtilsMethod {
     /// Transforms bech32 to hex
     Bech32ToHex {
-        /// Bech32 encoded address
         bech32: Bech32Address,
     },
     /// Transforms a hex encoded address to a bech32 encoded address
     #[serde(rename_all = "camelCase")]
     HexToBech32 {
-        /// Hex encoded bech32 address
         hex: String,
-        /// Human readable part
         bech32_hrp: Hrp,
     },
     /// Transforms an account id to a bech32 encoded address
     #[serde(rename_all = "camelCase")]
     AccountIdToBech32 {
-        /// Account ID
         account_id: AccountId,
-        /// Human readable part
         bech32_hrp: Hrp,
     },
     /// Transforms an nft id to a bech32 encoded address
     #[serde(rename_all = "camelCase")]
     NftIdToBech32 {
-        /// Nft ID
         nft_id: NftId,
-        /// Human readable part
         bech32_hrp: Hrp,
     },
     /// Transforms a hex encoded public key to a bech32 encoded address
     #[serde(rename_all = "camelCase")]
     HexPublicKeyToBech32Address {
-        /// Hex encoded public key
         hex: String,
-        /// Human readable part
         bech32_hrp: Hrp,
     },
     /// Returns a valid Address parsed from a String.
     ParseBech32Address {
-        /// Address
         address: Bech32Address,
     },
     /// Checks if a String is a valid bech32 encoded address.
     IsAddressValid {
-        /// Address
         address: String,
     },
     /// Generates a new mnemonic.
     GenerateMnemonic,
     /// Returns a hex encoded seed for a mnemonic.
     MnemonicToHexSeed {
-        /// Mnemonic
         #[derivative(Debug(format_with = "OmittedDebug::omitted_fmt"))]
         mnemonic: String,
     },
     /// Returns a block ID from a block and slot protocol parameters
     #[serde(rename_all = "camelCase")]
     BlockId {
-        /// Block
         block: BlockDto,
-        /// Network Protocol Parameters
         protocol_parameters: ProtocolParameters,
     },
     /// Returns the transaction ID (Blake2b256 hash of the provided transaction payload)
     TransactionId {
-        /// Transaction Payload
         payload: SignedTransactionPayloadDto,
     },
     /// Computes the account ID
     #[serde(rename_all = "camelCase")]
     ComputeAccountId {
-        /// Output ID
         output_id: OutputId,
     },
     /// Computes the Foundry ID
     #[serde(rename_all = "camelCase")]
     ComputeFoundryId {
-        /// Alias id
         account_id: AccountId,
-        /// Serial number
         serial_number: u32,
-        /// Token scheme kind
         token_scheme_type: u8,
     },
     /// Computes the NFT ID
     #[serde(rename_all = "camelCase")]
     ComputeNftId {
-        /// Output ID
         output_id: OutputId,
     },
     /// Computes the output ID from transaction id and output index
@@ -127,9 +107,13 @@ pub enum UtilsMethod {
         serial_number: u32,
         token_scheme_type: u8,
     },
+    /// Computes the hash of the given protocol parameters.
+    #[serde(rename_all = "camelCase")]
+    ProtocolParametersHash {
+        protocol_parameters: ProtocolParameters,
+    },
     /// Computes the signing hash of a transaction.
     TransactionSigningHash {
-        /// The transaction.
         transaction: TransactionDto,
     },
     /// Computes the minimum required amount of an output.

bindings/core/src/method_handler/utils.rs

@@ -70,6 +70,9 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
             let foundry_id = FoundryId::build(&AccountAddress::new(account_id), serial_number, token_scheme_type);
             Response::TokenId(TokenId::from(foundry_id))
         }
+        UtilsMethod::ProtocolParametersHash { protocol_parameters } => {
+            Response::Hash(protocol_parameters.hash().to_string())
+        }
         UtilsMethod::TransactionSigningHash { transaction } => {
             Response::Hash(Transaction::try_from_dto(transaction)?.signing_hash().to_string())
         }

bindings/nodejs/lib/types/models/info/node-info-protocol.ts

@@ -47,10 +47,18 @@ export interface ProtocolParameters {
      * Work Score Parameters lists the work score of each type, it is used to denote the computation costs of processing an object.
      */
     workScoreParameters: WorkScoreParameters;
+    /**
+     * The parameters used by mana calculation.
+     */
+    manaParameters: ManaParameters;
     /**
      * Current supply of base token.
      */
     tokenSupply: u64;
+    /**
+     * Genesis Slot defines the slot of the genesis.
+     */
+    genesisSlot: number;
     /**
      * The genesis timestamp at which the slots start to count.
      */
@@ -63,10 +71,6 @@ export interface ProtocolParameters {
      * The number of slots in an epoch expressed as an exponent of 2.
      */
     slotsPerEpochExponent: number;
-    /**
-     * The parameters used by mana calculation.
-     */
-    manaParameters: ManaParameters;
     /**
      * The unbonding period in epochs before an account can stop staking.
      */
@@ -80,9 +84,13 @@ export interface ProtocolParameters {
      */
     punishmentEpochs: number;
     /**
-     * Determine if a block is eligible by evaluating issuingTime and commitments in its pastcone to ATT and lastCommittedSlot respectively.
+     * Liveness Threshold Lower Bound is used by tip-selection to determine if a block is eligible by evaluating issuingTimes.
      */
-    livenessThreshold: number;
+    livenessThresholdLowerBound: number;
+    /**
+     * Liveness Threshold Upper Bound is used by tip-selection to determine if a block is eligible by evaluating issuingTimes.
+     */
+    livenessThresholdUpperBound: number;
     /**
      * MinCommittableAge is the minimum age relative to the accepted tangle time slot index that a slot can be committed.
      */
@@ -107,6 +115,10 @@ export interface ProtocolParameters {
      * Rewards Parameters defines the parameters that are used to calculate Mana rewards.
      */
     rewardsParameters: RewardsParameters;
+    /**
+     * Target Committee Size defines the target size of the committee. If there's fewer candidates the actual committee size could be smaller in a given epoch.
+     */
+    targetCommitteeSize: number;
 }
 
 /**

bindings/nodejs/lib/types/utils/bridge/index.ts

@@ -16,6 +16,7 @@ import type {
     __NftIdToBech32Method__,
     __HexPublicKeyToBech32AddressMethod__,
     __IsAddressValidMethod__,
+    __ProtocolParametersHashMethod__,
     __TransactionSigningHashMethod__,
     __VerifyEd25519SignatureMethod__,
     __VerifySecp256k1EcdsaSignatureMethod__,
@@ -45,6 +46,7 @@ export type __UtilsMethods__ =
     | __NftIdToBech32Method__
     | __HexPublicKeyToBech32AddressMethod__
     | __IsAddressValidMethod__
+    | __ProtocolParametersHashMethod__
     | __TransactionSigningHashMethod__
     | __VerifyEd25519SignatureMethod__
     | __VerifySecp256k1EcdsaSignatureMethod__

bindings/nodejs/lib/types/utils/bridge/utils.ts

@@ -145,6 +145,13 @@ export interface __IsAddressValidMethod__ {
     };
 }
 
+export interface __ProtocolParametersHashMethod__ {
+    name: 'protocolParametersHash';
+    data: {
+        protocolParameters: ProtocolParameters;
+    };
+}
+
 export interface __TransactionSigningHashMethod__ {
     name: 'transactionSigningHash';
     data: {

bindings/nodejs/lib/utils/utils.ts

@@ -322,6 +322,23 @@ export class Utils {
         });
     }
 
+    /**
+     * Compute the hash of an instance of ProtocolParameters.
+     *
+     * @param protocolParameters A ProtocolParameters instance.
+     * @returns The hash of the protocol parameters as a hex-encoded string.
+     */
+    static protocolParametersHash(
+        protocolParameters: ProtocolParameters,
+    ): HexEncodedString {
+        return callUtilsMethod({
+            name: 'protocolParametersHash',
+            data: {
+                protocolParameters,
+            },
+        });
+    }
+
     /**
      * Compute the signing hash of a transaction.
      *

bindings/nodejs/package.json

@@ -33,6 +33,7 @@
         "typescript": "^4.9.4"
     },
     "devDependencies": {
+        "@napi-rs/cli": "^1.0.0",
         "@types/jest": "^29.4.0",
         "@typescript-eslint/eslint-plugin": "^5.30.7",
         "@typescript-eslint/parser": "^5.30.7",
@@ -48,8 +49,7 @@
         "typedoc": "^0.24.6",
         "typedoc-plugin-markdown": "^3.14.0",
         "webpack": "^5.88.2",
-        "webpack-cli": "^5.1.4",
-        "@napi-rs/cli": "^1.0.0"
+        "webpack-cli": "^5.1.4"
     },
     "overrides": {
         "tar@<=4.4.17": "^4.4.19",

bindings/nodejs/tests/client/examples.spec.ts

@@ -1,7 +1,7 @@
 // Copyright 2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-import { describe, it } from '@jest/globals';
+import { expect, describe, it } from '@jest/globals';
 import {
     Client,
     utf8ToHex,

bindings/nodejs/tests/types/protocol_parameters.spec.ts

@@ -0,0 +1,21 @@
+// Copyright 2023 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import 'reflect-metadata';
+
+import { expect, describe, it } from '@jest/globals';
+import * as protocol_parameters from '../../../../sdk/tests/types/fixtures/protocol_parameters.json';
+import { ProtocolParameters } from '../../lib/types/models/info/node-info-protocol';
+import { Utils } from '../../';
+
+describe('ProtocolParameters tests', () => {
+
+    it('compares ProtocolParameters hash from a fixture', async () => {
+
+        const params = protocol_parameters.params as unknown as ProtocolParameters;
+        const hash = Utils.protocolParametersHash(params);
+        const expected_hash = protocol_parameters.hash;
+
+        expect(hash).toEqual(expected_hash);
+    });
+});