Merge branch 'main' into 20240908-addl-transient-error-detection

Author: RickyLB

examples/token_airdrop.rs

@@ -22,7 +22,7 @@ use std::iter::repeat;
 
 use clap::Parser;
 use hedera::{
-    AccountBalanceQuery, AccountCreateTransaction, AccountId, Client, Hbar, PrivateKey, TokenAirdropTransaction, TokenAssociateTransaction, TokenCreateTransaction, TokenDeleteTransaction, TokenGrantKycTransaction, TokenMintTransaction, TokenWipeTransaction, TransferTransaction
+    AccountBalanceQuery, AccountCreateTransaction, AccountId, Client, Hbar, PrivateKey, TokenAirdropTransaction, TokenCancelAirdropTransaction, TokenClaimAirdropTransaction, TokenCreateTransaction, TokenMintTransaction, TokenRejectTransaction
 };
 use time::{Duration, OffsetDateTime};
 
@@ -50,8 +50,8 @@ async fn main() -> anyhow::Result<()> {
     let client = Client::for_name(&hedera_network)?;
 
     client.set_operator(operator_account_id, operator_key.clone());
-    let private_key_1 = PrivateKey::generate_ed25519();
-    let alice = AccountCreateTransaction::new()
+    let private_key_1 = PrivateKey::generate_ecdsa();
+    let alice_id = AccountCreateTransaction::new()
         .key(private_key_1.public_key())
         .initial_balance(Hbar::new(10))
         .max_automatic_token_associations(-1)
@@ -62,8 +62,8 @@ async fn main() -> anyhow::Result<()> {
         .account_id
         .unwrap();
 
-    let private_key_2 = PrivateKey::generate_ed25519();
-    let bob = AccountCreateTransaction::new()
+    let private_key_2 = PrivateKey::generate_ecdsa();
+    let bob_id = AccountCreateTransaction::new()
         .key(private_key_2.public_key())
         .max_automatic_token_associations(1)
         .execute(&client)
@@ -73,8 +73,8 @@ async fn main() -> anyhow::Result<()> {
         .account_id
         .unwrap();
 
-    let private_key_3 = PrivateKey::generate_ed25519();
-    let carol = AccountCreateTransaction::new()
+    let private_key_3 = PrivateKey::generate_ecdsa();
+    let carol_id = AccountCreateTransaction::new()
         .key(private_key_3.public_key())
         .max_automatic_token_associations(0)
         .execute(&client)
@@ -84,7 +84,7 @@ async fn main() -> anyhow::Result<()> {
         .account_id
         .unwrap();
 
-    let treasury_key = PrivateKey::generate_ed25519();
+    let treasury_key = PrivateKey::generate_ecdsa();
     let treasury_account_id = AccountCreateTransaction::new()
         .key(treasury_key.public_key())
         .initial_balance(Hbar::new(10))
@@ -124,7 +124,6 @@ async fn main() -> anyhow::Result<()> {
     let nft_id = TokenCreateTransaction::new()
         .name("example NFT")
         .symbol("F")
-        .decimals(3)
         .max_supply(10)
         .treasury_account_id(treasury_account_id)
         .token_supply_type(hedera::TokenSupplyType::Finite)
@@ -135,7 +134,7 @@ async fn main() -> anyhow::Result<()> {
         .pause_key(operator_key.clone().public_key())
         .expiration_time(OffsetDateTime::now_utc() + Duration::hours(2))
         .freeze_with(&client)?
-        .sign(treasury_key)
+        .sign(treasury_key.clone())
         .execute(&client)
         .await?
         .get_receipt(&client)
@@ -157,13 +156,15 @@ async fn main() -> anyhow::Result<()> {
      */
     println!("Airdropping tokens to all accounts");
 
-    let airdrop_record = TokenAirdropTransaction::new()
-        .token_transfer(token_id, alice, 10)
+    let tx_record = TokenAirdropTransaction::new()
+        .token_transfer(token_id, alice_id, 10)
         .token_transfer(token_id, treasury_account_id, -10)
-        .token_transfer(token_id, bob, 10)
+        .token_transfer(token_id, bob_id, 10)
         .token_transfer(token_id, treasury_account_id, -10)
-        .token_transfer(token_id, carol, 10)
+        .token_transfer(token_id, carol_id, 10)
         .token_transfer(token_id, treasury_account_id, -10)
+        .freeze_with(&client)?
+        .sign(treasury_key.clone())
         .execute(&client)
         .await?
         .get_record(&client)
@@ -175,29 +176,29 @@ async fn main() -> anyhow::Result<()> {
      */
     println!(
         "Pending airdrop length: {}",
-        airdrop_record.pending_airdrop_records.len()
+        tx_record.pending_airdrop_records.len()
     );
     println!(
         "Pending airdrops: {:?}",
-        airdrop_record.pending_airdrop_records.get(0)
+        tx_record.pending_airdrop_records.get(0)
     );
 
     /*
      * Step 5:
      * Query to verify alice and bob received the airdrops and carol did not
      */
     let alice_balance = AccountBalanceQuery::new()
-        .account_id(alice)
+        .account_id(alice_id)
         .execute(&client)
         .await?;
 
     let bob_balance = AccountBalanceQuery::new()
-        .account_id(bob)
+        .account_id(bob_id)
         .execute(&client)
         .await?;
 
     let carol_balance = AccountBalanceQuery::new()
-        .account_id(carol)
+        .account_id(carol_id)
         .execute(&client)
         .await?;
 
@@ -209,10 +210,258 @@ async fn main() -> anyhow::Result<()> {
         "Bob ft balance after airdrop: {}",
         bob_balance.tokens.get(&token_id).unwrap()
     );
+    println!(
+        "Carol ft balance after airdrop: {:?}",
+        carol_balance.tokens.get(&token_id)
+    );
+
+    /*
+     * Step 6:
+     * Claim the airdrop for carol
+     */
+    println!("Claiming ft with Carol");
+
+    _ = TokenClaimAirdropTransaction::new()
+        .add_pending_airdrop_id(
+            tx_record
+                .pending_airdrop_records
+                .get(0)
+                .unwrap()
+                .pending_airdrop_id,
+        )
+        .freeze_with(&client)?
+        .sign(private_key_3.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    let carol_balance = AccountBalanceQuery::new()
+        .account_id(carol_id)
+        .execute(&client)
+        .await?;
+
     println!(
         "Carol ft balance after airdrop: {}",
         carol_balance.tokens.get(&token_id).unwrap()
     );
 
+    /*
+     * Step 7:
+     * Airdrop the NFTs to all three accounts
+     */
+    println!("Airdropping nfts");
+    let tx_record = TokenAirdropTransaction::new()
+        .nft_transfer(nft_id.nft(1), treasury_account_id, alice_id)
+        .nft_transfer(nft_id.nft(2), treasury_account_id, bob_id)
+        .nft_transfer(nft_id.nft(3), treasury_account_id, carol_id)
+        .freeze_with(&client)?
+        .sign(treasury_key.clone())
+        .execute(&client)
+        .await?
+        .get_record(&client)
+        .await?;
+
+    /*
+     * Step 8:
+     * Get the transaction record and verify two pending airdrops (for bob & carol)
+     */
+    println!(
+        "Pending airdrops length: {}",
+        tx_record.pending_airdrop_records.len()
+    );
+    println!(
+        "Pending airdrops for Bob: {}",
+        tx_record.pending_airdrop_records.get(0).unwrap()
+    );
+    println!(
+        "Pending airdrops for Carol: {}",
+        tx_record.pending_airdrop_records.get(1).unwrap()
+    );
+
+    /*
+     * Step 9:
+     * Query to verify alice received the airdrop and bob and carol did not
+     */
+    let alice_balance = AccountBalanceQuery::new()
+        .account_id(alice_id)
+        .execute(&client)
+        .await?;
+
+    let bob_balance = AccountBalanceQuery::new()
+        .account_id(bob_id)
+        .execute(&client)
+        .await?;
+
+    let carol_balance = AccountBalanceQuery::new()
+        .account_id(carol_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Alice nft balance after airdrop: {}",
+        alice_balance.tokens.get(&nft_id).unwrap()
+    );
+
+    println!(
+        "Bob nft balance after airdrop: {:?}",
+        bob_balance.tokens.get(&nft_id)
+    );
+
+    println!(
+        "Carol nft balance after airdrop: {:?}",
+        carol_balance.tokens.get(&nft_id)
+    );
+
+    /*
+     * Step 10:
+     * Claim the airdrop for bob
+     */
+    println!("Claiming nft with Bob");
+    _ = TokenClaimAirdropTransaction::new()
+        .add_pending_airdrop_id(
+            tx_record
+                .pending_airdrop_records
+                .get(0)
+                .unwrap()
+                .pending_airdrop_id,
+        )
+        .freeze_with(&client)?
+        .sign(private_key_2.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    let bob_balance = AccountBalanceQuery::new()
+        .account_id(bob_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Bob nft balance after claim: {}",
+        bob_balance.tokens.get(&nft_id).unwrap()
+    );
+
+    /*
+     * Step 11:
+     * Cancel the airdrop for carol
+     */
+    println!("Cancelling nft for Carol");
+
+    _ = TokenCancelAirdropTransaction::new()
+        .add_pending_airdrop_id(
+            tx_record
+                .pending_airdrop_records
+                .get(1)
+                .unwrap()
+                .pending_airdrop_id,
+        )
+        .freeze_with(&client)?
+        .sign(treasury_key.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    let carol_balance = AccountBalanceQuery::new()
+        .account_id(carol_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Carol nft balance after cancel: {:?}",
+        carol_balance.tokens.get(&nft_id)
+    );
+
+    /*
+     * Step 12:
+     * Reject the NFT for bob
+     */
+    println!("Rejecting nft with Bob");
+
+    _ = TokenRejectTransaction::new()
+        .owner(bob_id)
+        .add_nft_id(nft_id.nft(2))
+        .freeze_with(&client)?
+        .sign(private_key_2)
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    /*
+     * Step 13:
+     * Query to verify bob no longer has the NFT
+     */
+    let bob_balance = AccountBalanceQuery::new()
+        .account_id(bob_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Bob nft balance after reject: {}",
+        bob_balance.tokens.get(&nft_id).unwrap()
+    );
+
+    /*
+     * Step 13:
+     * Query to verify the NFT was returned to the Treasury
+     */
+    let treasury_balance = AccountBalanceQuery::new()
+        .account_id(treasury_account_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Treasury nft balance after reject: {}",
+        treasury_balance.tokens.get(&nft_id).unwrap()
+    );
+
+    /*
+     * Step 14:
+     * Reject the Fungible token for carol
+     */
+    println!("Rejecting ft with Carol");
+
+    _ = TokenRejectTransaction::new()
+        .owner(carol_id)
+        .add_token_id(token_id)
+        .freeze_with(&client)?
+        .sign(private_key_3.clone())
+        .execute(&client)
+        .await?
+        .get_receipt(&client)
+        .await?;
+
+    /*
+     * Step 14:
+     * Query to verify Carol no longer has the fungible tokens
+     */
+    let carol_balance = AccountBalanceQuery::new()
+        .account_id(carol_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Carol ft balance after reject: {}",
+        carol_balance.tokens.get(&token_id).unwrap()
+    );
+
+    /*
+     * Step 15:
+     * Query to verify Treasury received the rejected fungible tokens
+     */
+    let treasury_balance = AccountBalanceQuery::new()
+        .account_id(treasury_account_id)
+        .execute(&client)
+        .await?;
+
+    println!(
+        "Treasury ft balance after reject: {}",
+        treasury_balance.tokens.get(&token_id).unwrap()
+    );
+
+    println!("Token airdrop example completed successfully");
     Ok(())
 }

src/mirror_query/any.rs

@@ -59,9 +59,10 @@ impl MirrorQueryExecute for AnyMirrorQueryData {
 
     type Response = AnyMirrorQueryResponse;
 
-    type ItemStream<'a> = BoxStream<'a, crate::Result<Self::Item>>
-        where
-            Self: 'a;
+    type ItemStream<'a>
+        = BoxStream<'a, crate::Result<Self::Item>>
+    where
+        Self: 'a;
 
     fn subscribe_with_optional_timeout<'a>(
         &self,