iota-sdk 0.2.0

The IOTA SDK provides developers with a seamless experience to develop on IOTA by providing account abstractions and clients to interact with node APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// Copyright 2021 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use instant::Instant;

use crate::{
    client::{
        api::{
            input_selection::Selected, transaction::validate_regular_transaction_essence_length,
            PreparedTransactionData,
        },
        secret::types::InputSigningData,
    },
    types::block::{
        input::{Input, UtxoInput},
        output::{InputsCommitment, Output},
        payload::{
            transaction::{RegularTransactionEssence, TransactionEssence},
            Payload,
        },
    },
    wallet::account::{handle::AccountHandle, operations::transaction::TransactionOptions},
};

impl AccountHandle {
    /// Function to build the transaction essence from the selected in and outputs
    pub(crate) async fn build_transaction_essence(
        &self,
        selected_transaction_data: Selected,
        options: Option<TransactionOptions>,
    ) -> crate::wallet::Result<PreparedTransactionData> {
        log::debug!("[TRANSACTION] build_transaction");

        let build_transaction_essence_start_time = Instant::now();
        let protocol_parameters = self.client.get_protocol_parameters().await?;

        let mut inputs_for_essence: Vec<Input> = Vec::new();
        let mut inputs_for_signing: Vec<InputSigningData> = Vec::new();

        for utxo in &selected_transaction_data.inputs {
            let input = Input::Utxo(UtxoInput::from(*utxo.output_id()));
            inputs_for_essence.push(input.clone());
            inputs_for_signing.push(utxo.clone());
        }

        // Build transaction essence

        let input_outputs = inputs_for_signing
            .iter()
            .map(|i| i.output.clone())
            .collect::<Vec<Output>>();
        let inputs_commitment = InputsCommitment::new(input_outputs.iter());
        let mut essence_builder =
            RegularTransactionEssence::builder(protocol_parameters.network_id(), inputs_commitment);
        essence_builder = essence_builder.with_inputs(inputs_for_essence);
        essence_builder = essence_builder.with_outputs(selected_transaction_data.outputs);

        // Optional add a tagged payload
        if let Some(options) = options {
            if let Some(tagged_data_payload) = &options.tagged_data_payload {
                essence_builder =
                    essence_builder.with_payload(Payload::TaggedData(Box::new(tagged_data_payload.clone())));
            }
        }

        let essence = essence_builder.finish(&protocol_parameters)?;

        validate_regular_transaction_essence_length(&essence)?;

        let essence = TransactionEssence::Regular(essence);

        let prepared_transaction_data = PreparedTransactionData {
            essence,
            inputs_data: inputs_for_signing,
            remainder: selected_transaction_data.remainder,
        };

        log::debug!(
            "[TRANSACTION] finished build_transaction in {:.2?}",
            build_transaction_essence_start_time.elapsed()
        );
        Ok(prepared_transaction_data)
    }
}