Feat: node merge part 2

bindings/core/src/method/client.rs

@@ -125,6 +125,15 @@ pub enum ClientMethod {
     /// Returns the unhealthy nodes.
     #[cfg(not(target_family = "wasm"))]
     UnhealthyNodes,
+    /// Extension method which provides request methods for plugins.
+    #[serde(rename_all = "camelCase")]
+    PluginFetch {
+        base_plugin_path: String,
+        method: String,
+        method_path: String,
+        query_params: Vec<String>,
+        request_object: Option<String>,
+    },
     /// Prepare a transaction for signing
     #[serde(rename_all = "camelCase")]
     PrepareTransaction {

bindings/core/src/method/utils.rs

@@ -3,11 +3,14 @@
 
 use derivative::Derivative;
 use iota_sdk::types::block::{
-    address::{AliasAddress, Bech32Address, Hrp},
-    output::{AliasId, NftId, OutputId},
+    address::{Bech32Address, Hrp},
+    output::{dto::OutputDto, AliasId, NftId, OutputId, RentStructure, TokenScheme},
     payload::{
         dto::MilestonePayloadDto,
-        transaction::dto::{TransactionEssenceDto, TransactionPayloadDto},
+        transaction::{
+            dto::{TransactionEssenceDto, TransactionPayloadDto},
+            TransactionId,
+        },
     },
     signature::dto::Ed25519SignatureDto,
     BlockDto,
@@ -97,27 +100,41 @@ pub enum UtilsMethod {
         /// Output ID
         output_id: OutputId,
     },
+    /// Computes the Foundry ID
+    #[serde(rename_all = "camelCase")]
+    ComputeFoundryId {
+        /// Alias id
+        alias_id: AliasId,
+        /// Serial number
+        serial_number: u32,
+        /// Token scheme kind
+        token_scheme_kind: u8,
+    },
     /// Computes the NFT ID
     #[serde(rename_all = "camelCase")]
     ComputeNftId {
         /// Output ID
         output_id: OutputId,
     },
-    /// Computes the Foundry ID
+    /// Returns the output ID from transaction id and output index
+    ComputeOutputId { id: TransactionId, index: u16 },
+    /// Constructs a tokenId from the aliasId, serial number and token scheme type.
     #[serde(rename_all = "camelCase")]
-    ComputeFoundryId {
-        /// Alias address
-        alias_address: AliasAddress,
-        /// Serial number
+    ComputeTokenId {
+        alias_id: AliasId,
         serial_number: u32,
-        /// Token scheme kind
-        token_scheme_kind: u8,
+        token_scheme_type: TokenScheme,
     },
     /// Compute the hash of a transaction essence.
     HashTransactionEssence {
         /// The transaction essence
         essence: TransactionEssenceDto,
     },
+    /// Calculate the input commitment from the output objects that are used as inputs to fund the transaction.
+    ComputeInputsCommitment { inputs: Vec<OutputDto> },
+    /// Calculates the required storage deposit of an output.
+    #[serde(rename_all = "camelCase")]
+    ComputeStorageDeposit { output: OutputDto, rent: RentStructure },
     /// Checks if the given mnemonic is valid.
     /// Expected response: [`Ok`](crate::Response::Ok)
     VerifyMnemonic {

bindings/core/src/method_handler/client.rs

@@ -304,7 +304,7 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
         ClientMethod::GetBlockMetadata { block_id } => {
             Response::BlockMetadata(client.get_block_metadata(&block_id).await?)
         }
-        ClientMethod::GetBlockRaw { block_id } => Response::BlockRaw(client.get_block_raw(&block_id).await?),
+        ClientMethod::GetBlockRaw { block_id } => Response::Raw(client.get_block_raw(&block_id).await?),
         ClientMethod::GetOutput { output_id } => Response::OutputWithMetadataResponse(
             client
                 .get_output(&output_id)
@@ -318,13 +318,13 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
             &client.get_milestone_by_id(&milestone_id).await?,
         )),
         ClientMethod::GetMilestoneByIdRaw { milestone_id } => {
-            Response::MilestoneRaw(client.get_milestone_by_id_raw(&milestone_id).await?)
+            Response::Raw(client.get_milestone_by_id_raw(&milestone_id).await?)
         }
         ClientMethod::GetMilestoneByIndex { index } => {
             Response::Milestone(MilestonePayloadDto::from(&client.get_milestone_by_index(index).await?))
         }
         ClientMethod::GetMilestoneByIndexRaw { index } => {
-            Response::MilestoneRaw(client.get_milestone_by_index_raw(index).await?)
+            Response::Raw(client.get_milestone_by_index_raw(index).await?)
         }
         ClientMethod::GetUtxoChangesById { milestone_id } => {
             Response::MilestoneUtxoChanges(client.get_utxo_changes_by_id(&milestone_id).await?)
@@ -459,6 +459,18 @@ pub(crate) async fn call_client_method_internal(client: &Client, method: ClientM
         ClientMethod::RequestFundsFromFaucet { url, address } => {
             Response::Faucet(request_funds_from_faucet(&url, &address).await?)
         }
+        ClientMethod::PluginFetch {
+            base_plugin_path,
+            method,
+            method_path,
+            query_params,
+            request_object,
+        } => {
+            let data: String = client
+                .plugin_fetch(&base_plugin_path, &method, &method_path, query_params, request_object)
+                .await?;
+            Response::Raw(data.as_bytes().to_vec())
+        }
     };
     Ok(response)
 }

bindings/core/src/method_handler/utils.rs

@@ -4,8 +4,8 @@
 use iota_sdk::{
     client::{hex_public_key_to_bech32_address, hex_to_bech32, verify_mnemonic, Client},
     types::block::{
-        address::{dto::AddressDto, Address, ToBech32Ext},
-        output::{AliasId, FoundryId, NftId},
+        address::{dto::AddressDto, Address, AliasAddress, ToBech32Ext},
+        output::{AliasId, FoundryId, InputsCommitment, NftId, Output, OutputId, Rent, TokenId},
         payload::{transaction::TransactionEssence, MilestonePayload, TransactionPayload},
         signature::Ed25519Signature,
         Block,
@@ -48,15 +48,39 @@ pub(crate) fn call_utils_method_internal(method: UtilsMethod) -> Result<Response
             Response::TransactionId(payload.id())
         }
         UtilsMethod::ComputeAliasId { output_id } => Response::AliasId(AliasId::from(&output_id)),
-        UtilsMethod::ComputeNftId { output_id } => Response::NftId(NftId::from(&output_id)),
         UtilsMethod::ComputeFoundryId {
-            alias_address,
+            alias_id,
+            serial_number,
+            token_scheme_kind,
+        } => Response::FoundryId(FoundryId::build(
+            &AliasAddress::new(alias_id),
             serial_number,
             token_scheme_kind,
-        } => Response::FoundryId(FoundryId::build(&alias_address, serial_number, token_scheme_kind)),
-        UtilsMethod::HashTransactionEssence { essence } => Response::TransactionEssenceHash(prefix_hex::encode(
+        )),
+        UtilsMethod::ComputeNftId { output_id } => Response::NftId(NftId::from(&output_id)),
+        UtilsMethod::ComputeOutputId { id, index } => Response::OutputId(OutputId::new(id, index)?),
+        UtilsMethod::ComputeTokenId {
+            alias_id,
+            serial_number,
+            token_scheme_type,
+        } => {
+            let foundry_id = FoundryId::build(&AliasAddress::new(alias_id), serial_number, token_scheme_type.kind());
+            Response::TokenId(TokenId::from(foundry_id))
+        }
+        UtilsMethod::HashTransactionEssence { essence } => Response::Hash(prefix_hex::encode(
             TransactionEssence::try_from_dto_unverified(essence)?.hash(),
         )),
+        UtilsMethod::ComputeInputsCommitment { inputs } => {
+            let inputs = inputs
+                .into_iter()
+                .map(|o| Ok(Output::try_from_dto_unverified(o)?))
+                .collect::<Result<Vec<Output>>>()?;
+            Response::Hash(InputsCommitment::new(inputs.iter()).to_string())
+        }
+        UtilsMethod::ComputeStorageDeposit { output, rent } => {
+            let out = Output::try_from_dto_unverified(output)?;
+            Response::MinimumRequiredStorageDeposit(out.rent_cost(&rent).to_string())
+        }
         UtilsMethod::VerifyMnemonic { mut mnemonic } => {
             verify_mnemonic(&mnemonic)?;
             mnemonic.zeroize();

bindings/core/src/response.rs

@@ -26,7 +26,7 @@ use iota_sdk::{
             input::dto::UtxoInputDto,
             output::{
                 dto::{OutputDto, OutputMetadataDto},
-                AliasId, FoundryId, NftId, OutputId,
+                AliasId, FoundryId, NftId, OutputId, TokenId,
             },
             payload::{
                 dto::{MilestonePayloadDto, PayloadDto},
@@ -135,7 +135,10 @@ pub enum Response {
     BlockMetadata(BlockMetadataResponse),
     /// Response for:
     /// - [`GetBlockRaw`](crate::method::ClientMethod::GetBlockRaw)
-    BlockRaw(Vec<u8>),
+    /// - [`GetMilestoneByIdRaw`](crate::method::ClientMethod::GetMilestoneByIdRaw)
+    /// - [`GetMilestoneByIndexRaw`](crate::method::ClientMethod::GetMilestoneByIndexRaw)
+    /// - [`PluginFetch`](crate::method::ClientMethod::PluginFetch)
+    Raw(Vec<u8>),
     /// Response for:
     /// - [`GetOutput`](crate::method::ClientMethod::GetOutput)
     OutputWithMetadataResponse(OutputWithMetadataResponse),
@@ -152,10 +155,6 @@ pub enum Response {
     /// - [`GetMilestoneByIndex`](crate::method::ClientMethod::GetMilestoneByIndex)
     Milestone(MilestonePayloadDto),
     /// Response for:
-    /// - [`GetMilestoneByIdRaw`](crate::method::ClientMethod::GetMilestoneByIdRaw)
-    /// - [`GetMilestoneByIndexRaw`](crate::method::ClientMethod::GetMilestoneByIndexRaw)
-    MilestoneRaw(Vec<u8>),
-    /// Response for:
     /// - [`GetUtxoChangesById`](crate::method::ClientMethod::GetUtxoChangesById)
     /// - [`GetUtxoChangesByIndex`](crate::method::ClientMethod::GetUtxoChangesByIndex)
     MilestoneUtxoChanges(MilestoneUTXOChanges),
@@ -210,6 +209,9 @@ pub enum Response {
     /// - [`MilestoneId`](crate::method::UtilsMethod::MilestoneId)
     MilestoneId(MilestoneId),
     /// Response for:
+    /// - [`TokenId`](crate::method::UtilsMethod::TokenId)
+    TokenId(TokenId),
+    /// Response for:
     /// - [`TransactionId`](crate::method::UtilsMethod::TransactionId)
     TransactionId(TransactionId),
     /// Response for:
@@ -223,7 +225,8 @@ pub enum Response {
     FoundryId(FoundryId),
     /// Response for:
     /// - [`HashTransactionEssence`](crate::method::UtilsMethod::HashTransactionEssence)
-    TransactionEssenceHash(String),
+    /// - [`ComputeStorageDeposit`](crate::method::UtilsMethod::ComputeStorageDeposit)
+    Hash(String),
     /// Response for [`GetNodeInfo`](crate::method::ClientMethod::GetNodeInfo)
     NodeInfoWrapper(NodeInfoWrapper),
     /// Response for [`Bech32ToHex`](crate::method::UtilsMethod::Bech32ToHex)

bindings/nodejs/examples/client/10-mqtt.ts

@@ -1,7 +1,15 @@
 // Copyright 2021-2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-import { Client, initLogger } from '@iota/sdk';
+import {
+    Block,
+    Client,
+    initLogger,
+    MilestonePayload,
+    parsePayload,
+} from '@iota/sdk';
+import { plainToInstance } from 'class-transformer';
+
 require('dotenv').config({ path: '.env' });
 
 // Run with command:
@@ -24,14 +32,35 @@ async function run() {
     const topics = ['blocks'];
 
     const callback = function (error: Error, data: string) {
-        console.log(JSON.parse(data));
+        if (error != null) {
+            console.log(error);
+            return;
+        }
+
+        const parsed = JSON.parse(data);
+        if (parsed.topic == 'milestone') {
+            const payload = parsePayload(
+                JSON.parse(parsed.payload),
+            ) as MilestonePayload;
+            const index = payload.index;
+            const previousMilestone = payload.previousMilestoneId;
+            console.log(
+                'New milestone index' +
+                    index +
+                    ', previous ID: ' +
+                    previousMilestone,
+            );
+        } else if (parsed.topic == 'blocks') {
+            const block = plainToInstance(Block, JSON.parse(parsed.payload));
+            console.log('payload:', block.payload);
+        }
     };
 
     await client.listen(topics, callback);
 
     // Clear listener after 10 seconds
     setTimeout(async () => {
-        await client.clearListeners(['blocks']);
+        await client.clearListeners(topics);
         console.log('Listener cleared');
         // Exit the process
         setTimeout(async () => process.exit(0), 2000);

bindings/nodejs/examples/package.json

@@ -9,6 +9,7 @@
     },
     "dependencies": {
         "@iota/sdk": "link:../",
+        "class-transformer": "^0.5.1",
         "dotenv": "^16.0.0",
         "ts-node": "^10.9.1"
     },