feat: add detail to token_airdrop and token_airdrop_cancel

Signed-off-by: tech0priyanshu <[email protected]>

Author: tech0priyanshu

examples/token_airdrop.py

@@ -57,7 +57,7 @@ def create_account(client, operator_key):
 
 def create_token(client, operator_id, operator_key):
     """Create a fungible token"""
-    print("\nCreating a token...")
+    print("\nStep 1: Creating a fungible token (TKA)...")
     try:
         token_tx = (
             TokenCreateTransaction()
@@ -79,7 +79,7 @@ def create_token(client, operator_id, operator_key):
 
 def create_nft(client, operator_key, operator_id):
     """Create a NFT"""
-    print("\nCreating a nft...")
+    print("\nStep 2: Creating a non-fungible token (NFTA)...")
     try:
         nft_tx = (
             TokenCreateTransaction()
@@ -101,7 +101,7 @@ def create_nft(client, operator_key, operator_id):
 
 def mint_nft(client, operator_key, nft_id):
     """Mint the NFT with metadata"""
-    print("\nMinting a nft...")
+    print("\nStep 3: Minting an NFT for NFTA...")
     try:
         mint_tx = TokenMintTransaction(token_id=nft_id, metadata=[b"NFT data"])
         mint_tx.freeze_with(client)
@@ -117,7 +117,7 @@ def mint_nft(client, operator_key, nft_id):
 
 def associate_tokens(client, recipient_id, recipient_key, tokens):
     """Associate the token and nft with the recipient"""
-    print("\nAssociating tokens to recipient...")
+    print("\nStep 4: Associating tokens to recipient...")
     try:
         assocciate_tx = TokenAssociateTransaction(
             account_id=recipient_id,
@@ -132,10 +132,9 @@ def associate_tokens(client, recipient_id, recipient_key, tokens):
             .execute(client)
             .token_balances
         )
-        print("Tokens associated with recipient:")
-        print(f"{tokens[0]}: {balance_before.get(tokens[0])}")
-        print(f"{tokens[1]}: {balance_before.get(tokens[1])}")
-
+        print("Tokens associated with recipient (should be 0 for both):")
+        print(f"  {tokens[0]}: {balance_before.get(tokens[0], 0)}")
+        print(f"  {tokens[1]}: {balance_before.get(tokens[1], 0)}")
         print("\n✅ Success! Token association complete.")
 
     except Exception as e:
@@ -160,14 +159,25 @@ def token_airdrop():
     # Create a nft
     nft_id = create_nft(client, operator_key, operator_id)
 
-    #Mint nft
+    # Mint nft
     serial_number = mint_nft(client, operator_key, nft_id)
 
     # Associate tokens
     associate_tokens(client, recipient_id, recipient_key, [token_id, nft_id])
 
-    # Airdrop Tthe tokens
-    print("\nAirdropping tokens...")
+    # Log balances before airdrop
+    print("\nStep 5: Checking balances before airdrop...")
+    sender_balances_before = CryptoGetAccountBalanceQuery(account_id=operator_id).execute(client).token_balances
+    recipient_balances_before = CryptoGetAccountBalanceQuery(account_id=recipient_id).execute(client).token_balances
+    print(f"Sender ({operator_id}) balances before airdrop:")
+    print(f"  {token_id}: {sender_balances_before.get(token_id, 0)}")
+    print(f"  {nft_id}: {sender_balances_before.get(nft_id, 0)}")
+    print(f"Recipient ({recipient_id}) balances before airdrop:")
+    print(f"  {token_id}: {recipient_balances_before.get(token_id, 0)}")
+    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}...")
     try:
         airdrop_receipt = (
             TokenAirdropTransaction()
@@ -183,24 +193,35 @@ def token_airdrop():
         )
 
         if airdrop_receipt.status != ResponseCode.SUCCESS:
-            print(f"Fail to cancel airdrop: Status: {airdrop_receipt.status}")
+            print(f"❌ Fail to airdrop: Status: {airdrop_receipt.status}")
             sys.exit(1)
 
         print(f"Token airdrop ID: {airdrop_receipt.transaction_id}")
 
-        after_balance = (
-            CryptoGetAccountBalanceQuery(account_id=recipient_id)
-            .execute(client)
-            .token_balances
-        )
-        print("Recipient balance after token airdrop:")
-        print(f"{token_id}: {after_balance.get(token_id)}")
-        print(f"{nft_id}: {after_balance.get(nft_id)}")
-
+        # 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"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)}")
+
+        # 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("+----------------+----------------------+----------------------+----------------------+----------------------+")
         print("\n✅ Success! Token Airdrop transaction successful")
     except Exception as e:
         print(f"❌ Error airdropping tokens: {e}")
         sys.exit(1)
 
 if __name__ == "__main__":
     token_airdrop()
+

examples/token_cancel_airdrop.py

@@ -59,7 +59,7 @@ def token_cancel_airdrop():
         sys.exit(1)
 
     # Create two new tokens.
-    print("\nCreating two new tokens...")
+    print("\nStep 1: Creating two new fungible tokens...")
     try:
         tx1 = TokenCreateTransaction().set_token_name("First Token").set_token_symbol("TKA").set_initial_supply(1).set_treasury_account_id(operator_id)
         receipt1 = tx1.freeze_with(client).sign(operator_key).execute(client)
@@ -69,13 +69,31 @@ def token_cancel_airdrop():
         receipt2 = tx2.freeze_with(client).sign(operator_key).execute(client)
         token_id_2 = receipt2.token_id
 
-        print(f"Created tokens: {token_id_1} and {token_id_2}")
+        print(f"✅ Created tokens: {token_id_1} (TKA) and {token_id_2} (TKB)")
     except Exception as e:
         print(f"Error creating tokens: {e}")
         sys.exit(1)
 
+    # Log balances before airdrop
+    print("\nStep 2: Checking balances before airdrop...")
+    from hiero_sdk_python import CryptoGetAccountBalanceQuery
+    sender_balances_before = CryptoGetAccountBalanceQuery(account_id=operator_id).execute(client).token_balances
+
+    recipient_balances_before = CryptoGetAccountBalanceQuery(account_id=recipient_id).execute(client).token_balances
+    print(f"Sender ({operator_id}) balances before airdrop:")
+
+    print(f"  {str(token_id_1)}: {sender_balances_before.get(str(token_id_1), 0)}")
+
+    print(f"  {str(token_id_2)}: {sender_balances_before.get(str(token_id_2), 0)}")
+
+    print(f"Recipient ({recipient_id}) balances before airdrop:")
+
+    print(f"  {str(token_id_1)}: {recipient_balances_before.get(str(token_id_1), 0)}")
+
+    print(f"  {str(token_id_2)}: {recipient_balances_before.get(str(token_id_2), 0)}")
     # Airdrop the tokens.
-    print("\nAirdrop tokens...")
+    print(f"\nStep 3: Airdropping tokens TKA ({token_id_1}) and TKB ({token_id_2}) to recipient {recipient_id}...")
+
     try:
         receipt = (
             TokenAirdropTransaction()
@@ -90,6 +108,43 @@ def token_cancel_airdrop():
         print(f"Token airdrop complete: (status: {receipt.status}, transaction_id: {receipt.transaction_id})")
         airdrop_record = TransactionRecordQuery(receipt.transaction_id).execute(client)
         pending_airdrops_record = airdrop_record.new_pending_airdrops
+        # 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_1)}: {sender_balances_after.get(str(token_id_1), 0)}")
+
+        print(f"  {str(token_id_2)}: {sender_balances_after.get(str(token_id_2), 0)}")
+
+        print(f"Recipient ({recipient_id}):")
+
+        print(f"  {str(token_id_1)}: {recipient_balances_after.get(str(token_id_1), 0)}")
+
+        print(f"  {str(token_id_2)}: {recipient_balances_after.get(str(token_id_2), 0)}")
+
+
+
+        # Summary table
+
+        print("\nSummary Table:")
+
+        print("+----------------+----------------------+----------------------+----------------------+\n"
+
+              "| Token Symbol   | Token ID             | Sender Balance       | Recipient Balance    |\n"
+
+              "+----------------+----------------------+----------------------+----------------------+")
+
+        print(f"| TKA            | {str(token_id_1):<20} | {str(sender_balances_after.get(str(token_id_1), 0)):<20} | {str(recipient_balances_after.get(str(token_id_1), 0)):<20} |")
+
+        print(f"| TKB            | {str(token_id_2):<20} | {str(sender_balances_after.get(str(token_id_2), 0)):<20} | {str(recipient_balances_after.get(str(token_id_2), 0)):<20} |")
+
+        print("+----------------+----------------------+----------------------+----------------------+")
+
     except Exception as e:
         print(f"Error airdroping tokens: {e}")
         sys.exit(1)