hiero-sdk 0.42.1

The SDK for interacting with Hedera Hashgraph.
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
85
86

use hiero_sdk_proto::services;
use tonic::transport::Channel;

use super::{
    AnyTransactionData,
    ChunkInfo,
    ToTransactionDataProtobuf,
    TransactionBody,
    TransactionData,
    TransactionExecute,
};
use crate::{
    BoxGrpcFuture,
    Transaction,
    ValidateChecksums,
};

#[derive(Clone)]
pub(crate) struct CostTransactionData<D> {
    pub(crate) inner: D,
}

pub(crate) type CostTransaction<D> = Transaction<CostTransactionData<D>>;

impl<D: Clone> CostTransaction<D> {
    pub(crate) fn from_transaction(transaction: &Transaction<D>) -> Self {
        let transaction = transaction.clone();

        Self {
            body: TransactionBody {
                data: CostTransactionData { inner: transaction.body.data },
                node_account_ids: transaction.body.node_account_ids,
                transaction_valid_duration: transaction.body.transaction_valid_duration,
                max_transaction_fee: transaction.body.max_transaction_fee,
                transaction_memo: transaction.body.transaction_memo,
                transaction_id: transaction.body.transaction_id,
                operator: transaction.body.operator,
                is_frozen: transaction.body.is_frozen,
                regenerate_transaction_id: transaction.body.regenerate_transaction_id,
                custom_fee_limits: transaction.body.custom_fee_limits,
                batch_key: transaction.body.batch_key,
            },
            // cost transactions have no signers
            signers: Vec::new(),
            sources: transaction.sources,
        }
    }
}

impl<D: Into<AnyTransactionData>> From<CostTransactionData<D>> for AnyTransactionData {
    fn from(transaction: CostTransactionData<D>) -> Self {
        transaction.inner.into()
    }
}

impl<D: TransactionData> TransactionData for CostTransactionData<D> {
    #[doc(hidden)]
    fn for_cost_estimate(&self) -> bool {
        true
    }
}

impl<D: TransactionExecute> TransactionExecute for CostTransactionData<D> {
    fn execute(
        &self,
        channel: Channel,
        request: services::Transaction,
    ) -> BoxGrpcFuture<'_, services::TransactionResponse> {
        self.inner.execute(channel, request)
    }
}

impl<D: ValidateChecksums> ValidateChecksums for CostTransactionData<D> {
    fn validate_checksums(&self, ledger_id: &crate::ledger_id::RefLedgerId) -> crate::Result<()> {
        self.inner.validate_checksums(ledger_id)
    }
}

impl<D: ToTransactionDataProtobuf> ToTransactionDataProtobuf for CostTransactionData<D> {
    fn to_transaction_data_protobuf(
        &self,
        chunk_info: &ChunkInfo,
    ) -> services::transaction_body::Data {
        self.inner.to_transaction_data_protobuf(chunk_info)
    }
}