Merge pull request #512 from hashgraph/sr/final-examples

Author: mehcode

Cargo.lock

@@ -84,6 +84,7 @@ clap = { version = "4.0.0", features = ["derive", "env"] }
 dotenvy = "0.15.5"
 expect-test = "1.4.0"
 hex-literal = "0.4.0"
+miniserde = "0.1.30"
 parking_lot = "0.12.0"
 
 [dev-dependencies.tokio]

Cargo.toml

@@ -0,0 +1,123 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+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?
+                .valdiate_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)
+}

examples/contract/mod.rs

@@ -0,0 +1,107 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+use clap::Parser;
+use hedera::{
+    AccountBalanceQuery, AccountCreateTransaction, AccountId, Client, Hbar, Key, KeyList, PrivateKey, TransferTransaction
+};
+
+#[derive(Parser, Debug)]
+struct Args {
+    #[clap(long, env)]
+    operator_account_id: AccountId,
+
+    #[clap(long, env)]
+    operator_key: PrivateKey,
+
+    #[clap(long, env, default_value = "testnet")]
+    hedera_network: String,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let _ = dotenvy::dotenv();
+
+    let args = Args::parse();
+
+    let client = Client::for_name(&args.hedera_network)?;
+
+    client.set_operator(args.operator_account_id, args.operator_key);
+
+    // Generate three Ed25519::new private, public key pairs.
+    // You do not need the private keys to create the Threshold Key List,
+    // you only need the public keys, and if you're doing things correctly,
+    // you probably shouldn't have these private keys.
+    let private_keys = [
+        PrivateKey::generate_ed25519(),
+        PrivateKey::generate_ed25519(),
+        PrivateKey::generate_ed25519(),
+    ];
+
+    println!("public keys:");
+    for public_key in private_keys.iter().map(PrivateKey::public_key) {
+        println!("{public_key}");
+    }
+
+    // require 2 of the 3 keys we generated to sign on anything modifying this account
+    let transaction_key = KeyList {
+        keys: private_keys
+            .iter()
+            .map(PrivateKey::public_key)
+            .map(Key::from)
+            .collect(),
+        threshold: Some(2),
+    };
+
+    let transaction_response = AccountCreateTransaction::new()
+        .key(transaction_key)
+        .initial_balance(Hbar::new(10))
+        .execute(&client)
+        .await?;
+
+    // This will wait for the receipt to become available
+    let receipt = transaction_response.get_receipt(&client).await?;
+
+    let new_account_id = receipt.account_id.unwrap();
+
+    println!("account = {new_account_id}");
+
+    let transfer_transaction_response = TransferTransaction::new()
+        .hbar_transfer(new_account_id, Hbar::new(10).negated())
+        .hbar_transfer(AccountId::from(3), Hbar::new(10))
+        // we sign with 2 of the 3 keys
+        .sign(private_keys[0].clone())
+        .sign(private_keys[1].clone())
+        .execute(&client)
+        .await?;
+
+    // (important!) wait for the transfer to go to consensus
+    transfer_transaction_response.get_receipt(&client).await?;
+
+    let balance_after = AccountBalanceQuery::new()
+        .account_id(new_account_id)
+        .execute(&client)
+        .await?
+        .hbars;
+
+    println!("account balance after transfer: {balance_after}");
+
+    Ok(())
+}

examples/create_account_threshold_key.rs

@@ -0,0 +1,108 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+mod resources;
+
+use clap::Parser;
+use hedera::{
+    AccountId, Client, ContractCallQuery, ContractCreateTransaction, ContractDeleteTransaction, ContractFunctionParameters, FileCreateTransaction, PrivateKey
+};
+
+#[derive(Parser, Debug)]
+struct Args {
+    #[clap(long, env)]
+    operator_account_id: AccountId,
+
+    #[clap(long, env)]
+    operator_key: PrivateKey,
+
+    #[clap(long, env, default_value = "testnet")]
+    hedera_network: String,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let _ = dotenvy::dotenv();
+
+    let args = Args::parse();
+
+    let client = Client::for_name(&args.hedera_network)?;
+
+    client.set_operator(args.operator_account_id, args.operator_key.clone());
+
+    let bytecode = resources::simple_bytecode();
+
+    // create the contract's bytecode file
+    let file_transaction_response = FileCreateTransaction::new()
+        // Use the same key as the operator to "own" this file
+        .keys([args.operator_key.public_key()])
+        .contents(bytecode)
+        .execute(&client)
+        .await?;
+
+    let file_receipt = file_transaction_response.get_receipt(&client).await?;
+    let new_file_id = file_receipt.file_id.unwrap();
+
+    println!("contract bytecode file: {new_file_id}");
+
+    let contract_transaction_response = ContractCreateTransaction::new()
+        .bytecode_file_id(new_file_id)
+        .gas(500000)
+        .admin_key(args.operator_key.public_key())
+        .constructor_parameters(
+            ContractFunctionParameters::new()
+                .add_string("hello from hedera!")
+                .to_bytes(None),
+        )
+        .execute(&client)
+        .await?;
+
+    let contract_receipt = contract_transaction_response.get_receipt(&client).await?;
+    let new_contract_id = contract_receipt.contract_id.unwrap();
+
+    println!("new contract ID: {new_contract_id}");
+
+    let contract_call_result = ContractCallQuery::new()
+        .contract_id(new_contract_id)
+        .gas(500000)
+        .function("greet")
+        .execute(&client)
+        .await?;
+
+    if let Some(err) = contract_call_result.error_message {
+        anyhow::bail!("error calling contract: {err}");
+    }
+
+    let message = contract_call_result.get_str(0);
+    println!("contract returned message: {message:?}");
+
+    // now delete the contract
+    let _contract_delete_result = ContractDeleteTransaction::new()
+        .contract_id(new_contract_id)
+        .transfer_account_id(args.operator_account_id)
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    println!("Contract successfully deleted");
+
+    Ok(())
+}