iota_client/node/
message.rs

1// Copyright 2021 IOTA Stiftung
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::{Api, Client, Result};
5use bee_message::{Message, MessageId};
6use bee_rest_api::types::{
7    body::SuccessBody,
8    responses::{
9        MessageChildrenResponse, MessageMetadataResponse as MessageMetadata, MessageResponse, MessagesFindResponse,
10    },
11};
12
13use std::convert::TryFrom;
14
15/// Builder of GET /api/v1/messages/{messageId} endpoint
16pub struct GetMessageBuilder<'a> {
17    client: &'a Client,
18}
19
20impl<'a> GetMessageBuilder<'a> {
21    /// Create GET /api/v1/messages endpoint builder
22    pub fn new(client: &'a Client) -> Self {
23        Self { client }
24    }
25
26    /// GET /api/v1/messages?index={Index} endpoint
27    /// Consume the builder and search for messages matching the index
28    pub async fn index<I: AsRef<[u8]>>(self, index: I) -> Result<Box<[MessageId]>> {
29        let path = "api/v1/messages";
30
31        let resp: SuccessBody<MessagesFindResponse> = self
32            .client
33            .node_manager
34            .get_request(
35                path,
36                Some(&format!("index={}", hex::encode(index))),
37                self.client.get_timeout(Api::GetMessage),
38            )
39            .await?;
40
41        resp.data
42            .message_ids
43            .iter()
44            .map(|s| {
45                let mut message_id = [0u8; 32];
46                hex::decode_to_slice(s, &mut message_id)?;
47                Ok(MessageId::from(message_id))
48            })
49            .collect::<Result<Box<[MessageId]>>>()
50    }
51
52    /// GET /api/v1/messages/{messageID} endpoint
53    /// Consume the builder and find a message by its identifer. This method returns the given message object.
54    pub async fn data(self, message_id: &MessageId) -> Result<Message> {
55        let path = &format!("api/v1/messages/{message_id}");
56
57        let resp: SuccessBody<MessageResponse> = self
58            .client
59            .node_manager
60            .get_request(path, None, self.client.get_timeout(Api::GetMessage))
61            .await?;
62
63        Ok(Message::try_from(&resp.data.0)?)
64    }
65
66    /// GET /api/v1/messages/{messageID}/metadata endpoint
67    /// Consume the builder and find a message by its identifer. This method returns the given message metadata.
68    pub async fn metadata(self, message_id: &MessageId) -> Result<MessageMetadata> {
69        let path = &format!("api/v1/messages/{message_id}/metadata");
70
71        let resp: SuccessBody<MessageMetadata> = self
72            .client
73            .node_manager
74            .get_request(path, None, self.client.get_timeout(Api::GetMessage))
75            .await?;
76
77        Ok(resp.data)
78    }
79
80    /// GET /api/v1/messages/{messageID}/raw endpoint
81    /// Consume the builder and find a message by its identifer. This method returns the given message raw data.
82    pub async fn raw(self, message_id: &MessageId) -> Result<String> {
83        let path = &format!("api/v1/messages/{message_id}/raw");
84        let resp = self
85            .client
86            .node_manager
87            .get_request_text(path, None, self.client.get_timeout(Api::GetMessage))
88            .await?;
89
90        Ok(resp)
91    }
92
93    /// GET /api/v1/messages/{messageID}/children endpoint
94    /// Consume the builder and returns the list of message IDs that reference a message by its identifier.
95    pub async fn children(self, message_id: &MessageId) -> Result<Box<[MessageId]>> {
96        let path = &format!("api/v1/messages/{message_id}/children");
97
98        let resp: SuccessBody<MessageChildrenResponse> = self
99            .client
100            .node_manager
101            .get_request(path, None, self.client.get_timeout(Api::GetMessage))
102            .await?;
103
104        resp.data
105            .children_message_ids
106            .iter()
107            .map(|s| {
108                let mut message_id = [0u8; 32];
109                hex::decode_to_slice(s, &mut message_id)?;
110                Ok(MessageId::from(message_id))
111            })
112            .collect::<Result<Box<[MessageId]>>>()
113    }
114}