fix: correct typo in token airdrop example and update CHANGELOG.md

Author: tech0priyanshu

CHANGELOG.md

@@ -26,8 +26,11 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 - AccountId support for ECDSA alias accounts
 - ContractId.to_evm_address() method for EVM compatibility
 - consumeLargeData() function in StatefulContract
-- example script for Token Airdrop
-- added variables directly in the example script to reduce the need for users to supply extra environment variables.
+- Added comprehensive example script for Token Airdrop (`token_airdrop.py`) that demonstrates:
+- Creating and airdropping both fungible tokens and NFTs with specific serial numbers
+- Verifying token transfers using transaction records and balance checks
+- Detailed transaction result reporting with visual summary tables
+- Added variables directly in the example script to reduce the need for users to supply extra environment variables.
 - Added new `merge_conflicts.md` with detailed guidance on handling conflicts during rebase.
 
 ### Changed

examples/token_airdrop.py

@@ -15,8 +15,10 @@
  CryptoGetAccountBalanceQuery,
  TokenType,
  ResponseCode,
- NftId
+ NftId,
+ TransactionRecordQuery
 )
+ # Check the transaction record to verify the contents
 
 load_dotenv()
 
@@ -119,13 +121,18 @@ def associate_tokens(client, recipient_id, recipient_key, tokens):
     """Associate the token and nft with the recipient"""
     print("\nStep 4: Associating tokens to recipient...")
     try:
-        assocciate_tx = TokenAssociateTransaction(
+        associate_tx = TokenAssociateTransaction(
             account_id=recipient_id,
             token_ids=tokens
         )
-        assocciate_tx.freeze_with(client)
-        assocciate_tx.sign(recipient_key)
-        assocciate_tx.execute(client)
+        associate_tx.freeze_with(client)
+        associate_tx.sign(recipient_key)
+        associate_receipt = associate_tx.execute(client)
+
+        # Verify association was successful
+        if associate_receipt.status != ResponseCode.SUCCESS:
+            print(f"❌ Failed to associate tokens: Status: {associate_receipt.status}")
+            sys.exit(1)
 
         balance_before = (
             CryptoGetAccountBalanceQuery(account_id=recipient_id)
@@ -161,6 +168,7 @@ def token_airdrop():
 
     # Mint nft
     serial_number = mint_nft(client, operator_key, nft_id)
+    print(f"Using NFT with serial #{serial_number} for the airdrop")
 
     # Associate tokens
     associate_tokens(client, recipient_id, recipient_key, [token_id, nft_id])
@@ -177,7 +185,9 @@ def token_airdrop():
     print(f"  {nft_id}: {recipient_balances_before.get(nft_id, 0)}")
 
     # Airdrop the tokens
-    print(f"\nStep 6: Airdropping fungible token TKA ({token_id}) and NFTA ({nft_id}, serial {serial_number}) to recipient {recipient_id}...")
+    print(f"\nStep 6: Airdropping tokens to recipient {recipient_id}:")
+    print(f"  - 1 fungible token TKA ({token_id})")
+    print(f"  - NFT from NFTA collection ({nft_id}) with serial number #{serial_number}")
     try:
         airdrop_receipt = (
             TokenAirdropTransaction()
@@ -197,25 +207,106 @@ def token_airdrop():
             sys.exit(1)
 
         print(f"Token airdrop ID: {airdrop_receipt.transaction_id}")
-
+        print("\nVerifying airdrop contents:")
+        print(f"  - Transaction status: {airdrop_receipt.status}")
+        
+        record = TransactionRecordQuery(transaction_id=airdrop_receipt.transaction_id).execute(client)
+        
+        # Check token transfers
+        print("  - Token transfers in this transaction:")
+        expected_token_transfer = False
+        for token_id_key, transfers in record.token_transfers.items():
+            is_expected_token = token_id_key == token_id
+            token_indicator = "✓ EXPECTED" if is_expected_token else ""
+            print(f"    Token {token_id_key}: {token_indicator}")
+            
+            # Check for the expected transfer pattern
+            sender_sent_one = False
+            recipient_received_one = False
+            
+            for account, amount in transfers.items():
+                if amount > 0:
+                    print(f"      → {account} received {amount} token(s)")
+                    if account == recipient_id and amount == 1 and is_expected_token:
+                        recipient_received_one = True
+                else:
+                    print(f"      → {account} sent {abs(amount)} token(s)")
+                    if account == operator_id and amount == -1 and is_expected_token:
+                        sender_sent_one = True
+                        
+            if sender_sent_one and recipient_received_one:
+                expected_token_transfer = True
+            
+        # Verify the expected fungible token transfer
+        print("\nVerifying expected fungible token transfer:")
+        if expected_token_transfer:
+            print(f"  ✅ Success! 1 token of {token_id} (TKA) was successfully transferred")
+            print(f"      from {operator_id} to {recipient_id}")
+        else:
+            print(f"  ⚠️ Warning: Could not confirm transfer of 1 token of {token_id} (TKA)")
+            print(f"      This might indicate an issue with the transaction or record retrieval")
+        
+        # Instead of trying to parse the NFT transfers from the record (which has a complex structure),
+        # we'll verify the NFT transfer through balance changes, which is more reliable
+        print("  - Verifying NFT transfer through balance changes:")
+        expected_serial_transferred = False
+        
+        # Check if balances reflect the NFT transfer
+        try:
+            # Get updated balances right now to verify transfer
+            sender_current = CryptoGetAccountBalanceQuery(account_id=operator_id).execute(client).token_balances
+            recipient_current = CryptoGetAccountBalanceQuery(account_id=recipient_id).execute(client).token_balances
+            
+            # Check if the NFT balance changed as expected
+            sender_nft_before = sender_balances_before.get(nft_id, 0)
+            sender_nft_after = sender_current.get(nft_id, 0)
+            recipient_nft_before = recipient_balances_before.get(nft_id, 0)
+            recipient_nft_after = recipient_current.get(nft_id, 0)
+            
+            print(f"    Sender NFT balance: {sender_nft_before} -> {sender_nft_after}")
+            print(f"    Recipient NFT balance: {recipient_nft_before} -> {recipient_nft_after}")
+            
+            # If the sender's balance decreased by 1 and the recipient's increased by 1, 
+            # we can infer that the NFT was transferred
+            if sender_nft_before > sender_nft_after and recipient_nft_after > recipient_nft_before:
+                expected_serial_transferred = True
+                print(f"    ✓ EXPECTED: Balance changes confirm NFT transfer")
+                print(f"      → NFT with serial #{serial_number} was transferred from {operator_id} to {recipient_id}")
+            
+        except Exception as e:
+            print(f"    Error verifying NFT transfer through balances: {str(e)}")
+        
+        # Store the updated balances for later use
+        sender_balances_after = sender_current
+        recipient_balances_after = recipient_current
+        
+        # Verify the specific serial we intended to transfer
+        print("\nVerifying expected NFT transfer:")
+        if expected_serial_transferred:
+            print(f"  ✅ Success! NFT {nft_id} with serial #{serial_number} was successfully transferred")
+            print(f"      from {operator_id} to {recipient_id}")
+        else:
+            print(f"  ⚠️ Warning: Could not confirm transfer of NFT {nft_id} with serial #{serial_number}")
+            print(f"      This might indicate an issue with the transaction or record retrieval")
+        
         # Log balances after airdrop
         sender_balances_after = CryptoGetAccountBalanceQuery(account_id=operator_id).execute(client).token_balances
         recipient_balances_after = CryptoGetAccountBalanceQuery(account_id=recipient_id).execute(client).token_balances
         print("\nBalances after airdrop:")
         print(f"Sender ({operator_id}):")
-        print(f"  {str(token_id)}: {sender_balances_after.get(str(token_id), 0)}")
-        print(f"  {str(nft_id)}: {sender_balances_after.get(str(nft_id), 0)}")
+        print(f"  {token_id}: {sender_balances_after.get(token_id, 0)}")
+        print(f"  {nft_id}: {sender_balances_after.get(nft_id, 0)}")
         print(f"Recipient ({recipient_id}):")
-        print(f"  {str(token_id)}: {recipient_balances_after.get(str(token_id), 0)}")
-        print(f"  {str(nft_id)}: {recipient_balances_after.get(str(nft_id), 0)}")
+        print(f"  {token_id}: {recipient_balances_after.get(token_id, 0)}")
+        print(f"  {nft_id}: {recipient_balances_after.get(nft_id, 0)}")
 
         # Summary table
         print("\nSummary Table:")
         print("+----------------+----------------------+----------------------+----------------------+----------------------+")
         print("| Token Type     | Token ID             | NFT Serial          | Sender Balance       | Recipient Balance    |")
         print("+----------------+----------------------+----------------------+----------------------+----------------------+")
-        print(f"| Fungible (TKA) | {str(token_id):20} | -{'':20} | {str(sender_balances_after.get(str(token_id), 0)):20} | {str(recipient_balances_after.get(str(token_id), 0)):20} |")
-        print(f"| NFT (NFTA)     | {str(nft_id):20} | {str(serial_number):20} | {str(sender_balances_after.get(str(nft_id), 0)):20} | {str(recipient_balances_after.get(str(nft_id), 0)):20} |")
+        print(f"| Fungible (TKA) | {str(token_id):20} | {'N/A':20} | {str(sender_balances_after.get(token_id, 0)):20} | {str(recipient_balances_after.get(token_id, 0)):20} |")
+        print(f"| NFT (NFTA)     | {str(nft_id):20} | #{str(serial_number):19} | {str(sender_balances_after.get(nft_id, 0)):20} | {str(recipient_balances_after.get(nft_id, 0)):20} |")
         print("+----------------+----------------------+----------------------+----------------------+----------------------+")
         print("\n✅ Success! Token Airdrop transaction successful")
     except Exception as e: