hedera 0.32.0

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

// SPDX-License-Identifier: Apache-2.0

use hedera::{
    AccountId, Client, ContractCreateFlow, ContractExecuteTransaction, ContractFunctionParameters,
    ContractFunctionResult, ContractId, Hbar, PrivateKey, TransactionId,
};

#[derive(Default)]
pub struct ContractStep {
    pub result_inspector: Option<fn(&ContractFunctionResult)>,
    pub parameters: Option<Box<dyn Fn() -> ContractFunctionParameters>>,
    pub payable_amount: Option<Hbar>,
    pub signers: Vec<PrivateKey>,
    pub fee_payer: Option<AccountId>,
}

pub struct ContractHelper {
    contract_id: ContractId,
    steps: Vec<ContractStep>,
}

impl ContractHelper {
    pub fn new(contract_id: ContractId, steps: Vec<ContractStep>) -> Self {
        Self { contract_id, steps }
    }

    pub async fn execute(&self, client: &Client) -> hedera::Result<()> {
        for (index, step) in self.steps.iter().enumerate() {
            println!("Attempting to execute step {index}");

            let mut tx = ContractExecuteTransaction::new();

            tx.contract_id(self.contract_id).gas(10_000_000);

            if let Some(payable_amount) = step.payable_amount {
                tx.payable_amount(payable_amount);
            }

            let function_name = format!("step{index}");
            let params = step.parameters.as_deref().map(|it| it());

            match params {
                Some(params) => tx.function_with_parameters(&function_name, &params),
                None => tx.function(&function_name),
            };

            if let Some(fee_payer) = step.fee_payer {
                tx.transaction_id(TransactionId::generate(fee_payer));
            }

            tx.freeze_with(client)?;

            for signer in &step.signers {
                tx.sign(signer.clone());
            }

            let record = tx
                .execute(client)
                .await?
                .validate_status(false)
                .get_record(client)
                .await?;

            if let Err(e) = record.receipt.validate_status(true) {
                eprintln!("Error occurred during step{index}: {e}");
                eprintln!("Transaction record: {record:?}");
                break;
            }

            let function_result = record.contract_function_result.unwrap();
            println!("gas used: {}", function_result.gas_used);

            if let Some(inspector) = step.result_inspector {
                inspector(&function_result)
            }

            println!(
                "step {index} completed, and returned valid result. (TransactionId `{}`",
                record.transaction_id
            );
        }

        Ok(())
    }
}

pub async fn create_contract(
    client: &Client,
    bytecode: &str,
    constructor_parameters: ContractFunctionParameters,
) -> hedera::Result<ContractId> {
    let contract_id = ContractCreateFlow::new()
        .bytecode_hex(bytecode)?
        .max_chunks(30)
        .gas(8_000_000)
        .constructor_parameters(constructor_parameters.to_bytes(None))
        .execute(client)
        .await?
        .get_receipt(client)
        .await?
        .contract_id
        .unwrap();

    Ok(contract_id)
}