Bindings: Add ProtocolParameters tests

bindings/core/src/method/utils.rs

@@ -29,95 +29,51 @@ use crate::OmittedDebug;
 #[non_exhaustive]
 pub enum UtilsMethod {
     /// Transforms bech32 to hex
-    Bech32ToHex {
-        /// Bech32 encoded address
-        bech32: Bech32Address,
-    },
+    Bech32ToHex { 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,
-    },
+    HexToBech32 { hex: String, 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,
-    },
+    AccountIdToBech32 { account_id: AccountId, 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,
-    },
+    NftIdToBech32 { nft_id: NftId, 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,
-    },
+    HexPublicKeyToBech32Address { hex: String, bech32_hrp: Hrp },
     /// Returns a valid Address parsed from a String.
-    ParseBech32Address {
-        /// Address
-        address: Bech32Address,
-    },
+    ParseBech32Address { address: Bech32Address },
     /// Checks if a String is a valid bech32 encoded address.
-    IsAddressValid {
-        /// Address
-        address: String,
-    },
+    IsAddressValid { 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,
-    },
+    TransactionId { payload: SignedTransactionPayloadDto },
     /// Computes the account ID
     #[serde(rename_all = "camelCase")]
-    ComputeAccountId {
-        /// Output ID
-        output_id: OutputId,
-    },
+    ComputeAccountId { 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,
-    },
+    ComputeNftId { output_id: OutputId },
     /// Computes the output ID from transaction id and output index
     ComputeOutputId { id: TransactionId, index: u16 },
     /// Computes a tokenId from the aliasId, serial number and token scheme type.
@@ -127,11 +83,11 @@ 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,
-    },
+    TransactionSigningHash { transaction: TransactionDto },
     /// Computes the minimum required amount of an output.
     #[serde(rename_all = "camelCase")]
     ComputeMinimumOutputAmount {

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);
+    });
+});