TokenDissociateTransaction

TokenDissociateTransaction

Test token association

transfer out

operator

Author: exploreriii

README.md

@@ -13,6 +13,7 @@ submitting messages.
   - [Creating an Account](#creating-an-account)
   - [Creating a Token](#creating-a-token)
   - [Associating a Token](#associating-a-token)
+  - [Dissociating a Token](#dissociating-a-token)
   - [Transferring Tokens](#transferring-tokens)
   - [Deleting a Token](#deleting-a-token)
   - [Transferring HBAR](#transferring-hbar)
@@ -97,13 +98,14 @@ New Account Private Key: 228a06c363b0eb328434d51xxx...
 New Account Public Key: 8f444e36e8926def492adxxx...
 Token creation successful. Token ID: 0.0.5025xxx
 Token association successful.
+Token dissociation successful.
 Token transfer successful.
 Token deletion successful.
 ```
 
 ## Usage
 
-Below are examples of how to use the SDK for creating tokens, associating them with accounts, and transferring or deleting tokens (also see 'examples' directiory)
+Below are examples of how to use the SDK for creating tokens, associating them with accounts, dissociating them from accounts, and transferring or deleting tokens (also see 'examples' directiory)
 
 ### Creating an Account
 
@@ -153,6 +155,20 @@ transaction = (
     transaction.execute(client)
 ```
 
+### Dissociating a Token
+
+```
+transaction = (
+        TokenDissociateTransaction()
+        .set_account_id(recipient_id)
+        .add_token_id(token_id)
+        .freeze_with(client)
+        .sign(recipient_key)
+    )
+
+    transaction.execute(client)
+```
+
 ### Transfering a Token
 
 ```

examples/token_dissociate.py

@@ -0,0 +1,75 @@
+import os
+import sys
+from dotenv import load_dotenv
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.insert(0, project_root)
+
+from hedera_sdk_python.client.client import Client
+from hedera_sdk_python.account.account_id import AccountId
+from hedera_sdk_python.crypto.private_key import PrivateKey
+from hedera_sdk_python.client.network import Network
+from hedera_sdk_python.tokens.token_id import TokenId
+from hedera_sdk_python.tokens.token_dissociate_transaction import TokenDissociateTransaction
+
+load_dotenv()
+
+def dissociate_token(): #Single token
+    network = Network(network='testnet')
+    client = Client(network)
+
+    recipient_id = AccountId.from_string(os.getenv('OPERATOR_ID'))
+    recipient_key = PrivateKey.from_string(os.getenv('OPERATOR_KEY'))
+    token_id = TokenId.from_string('TOKEN_ID')
+
+    client.set_operator(recipient_id, recipient_key)
+
+    transaction = (
+        TokenDissociateTransaction()
+        .set_account_id(recipient_id)
+        .add_token_id(token_id)
+        .freeze_with(client)
+        .sign(recipient_key)
+    )
+
+    try:
+        receipt = transaction.execute(client)
+        print("Token dissociation successful.")
+    except Exception as e:
+        print(f"Token dissociation failed: {str(e)}")
+        sys.exit(1)
+
+def dissociate_tokens():  # Multiple tokens
+    network = Network(network='testnet')
+    client = Client(network)
+
+    recipient_id = AccountId.from_string(os.getenv('OPERATOR_ID'))
+    recipient_key = PrivateKey.from_string(os.getenv('OPERATOR_KEY'))
+    token_ids = [TokenId.from_string('TOKEN_ID_1'), TokenId.from_string('TOKEN_ID_2')]  
+
+    client.set_operator(recipient_id, recipient_key)
+
+    transaction = (
+        TokenDissociateTransaction()
+        .set_account_id(recipient_id)
+    )
+
+    for token_id in token_ids:
+        transaction.add_token_id(token_id)
+
+    transaction = (
+        transaction
+        .freeze_with(client)
+        .sign(recipient_key)
+    )
+
+    try:
+        receipt = transaction.execute(client)
+        print("Token dissociations successful.")
+    except Exception as e:
+        print(f"Token dissociations failed: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    dissociate_token()       # For single token dissociation
+    # dissociate_tokens()    # For multiple token dissociation

src/hedera_sdk_python/tokens/token_dissociate_transaction.py

@@ -0,0 +1,101 @@
+from hedera_sdk_python.transaction.transaction import Transaction
+from hedera_sdk_python.hapi import token_dissociate_pb2
+from hedera_sdk_python.response_code import ResponseCode
+
+class TokenDissociateTransaction(Transaction):
+    """
+    Represents a token dissociate transaction on the Hedera network.
+
+    This transaction dissociates the specified tokens with an account,
+    meaning the account can no longer hold or transact with those tokens.
+
+    Inherits from the base Transaction class and implements the required methods
+    to build and execute a token dissociate transaction.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new TokenDissociateTransaction instance with default values.
+        """
+        super().__init__()
+        self.account_id = None
+        self.token_ids = []
+
+        self._default_transaction_fee = 500_000_000
+
+    def set_account_id(self, account_id):
+        self._require_not_frozen()
+        self.account_id = account_id
+        return self
+
+    def add_token_id(self, token_id):
+        self._require_not_frozen()
+        self.token_ids.append(token_id)
+        return self
+
+    def build_transaction_body(self):
+        """
+        Builds and returns the protobuf transaction body for token dissociation.
+
+        Returns:
+            TransactionBody: The protobuf transaction body containing the token dissociation details.
+
+        Raises:
+            ValueError: If account ID or token IDs are not set.
+        """
+        if not self.account_id or not self.token_ids:
+            raise ValueError("Account ID and token IDs must be set.")
+
+        token_dissociate_body = token_dissociate_pb2.TokenDissociateTransactionBody(
+            account=self.account_id.to_proto(),
+            tokens=[token_id.to_proto() for token_id in self.token_ids]
+        )
+
+        transaction_body = self.build_base_transaction_body()
+        transaction_body.tokenDissociate.CopyFrom(token_dissociate_body)
+
+        return transaction_body
+    
+    def _execute_transaction(self, client, transaction_proto):
+        """
+        Executes the token dissociation transaction using the provided client.
+
+        Args:
+            client (Client): The client instance to use for execution.
+            transaction_proto (Transaction): The protobuf Transaction message.
+
+        Returns:
+            TransactionReceipt: The receipt from the network after transaction execution.
+
+        Raises:
+            Exception: If the transaction submission fails or receives an error response.
+        """
+        response = client.token_stub.dissociateTokens(transaction_proto)
+
+        if response.nodeTransactionPrecheckCode != ResponseCode.OK:
+            error_code = response.nodeTransactionPrecheckCode
+            error_message = ResponseCode.get_name(error_code)
+            raise Exception(f"Error during transaction submission: {error_code} ({error_message})")
+
+        receipt = self.get_receipt(client)
+        return receipt
+
+    def get_receipt(self, client, timeout=60):
+        """
+        Retrieves the receipt for the transaction.
+
+        Args:
+            client (Client): The client instance.
+            timeout (int): Maximum time in seconds to wait for the receipt.
+
+        Returns:
+            TransactionReceipt: The transaction receipt from the network.
+
+        Raises:
+            Exception: If the transaction ID is not set or if receipt retrieval fails.
+        """
+        if self.transaction_id is None:
+            raise Exception("Transaction ID is not set.")
+
+        receipt = client.get_transaction_receipt(self.transaction_id, timeout)
+        return receipt

test.py

@@ -9,12 +9,12 @@
 from hedera_sdk_python.crypto.public_key import PublicKey
 from hedera_sdk_python.tokens.token_create_transaction import TokenCreateTransaction
 from hedera_sdk_python.tokens.token_associate_transaction import TokenAssociateTransaction
+from hedera_sdk_python.tokens.token_dissociate_transaction import TokenDissociateTransaction
 from hedera_sdk_python.transaction.transfer_transaction import TransferTransaction
 from hedera_sdk_python.response_code import ResponseCode
 from hedera_sdk_python.consensus.topic_create_transaction import TopicCreateTransaction
 from hedera_sdk_python.tokens.token_delete_transaction import TokenDeleteTransaction
 from cryptography.hazmat.primitives import serialization
-
 load_dotenv()
 
 def load_operator_credentials():
@@ -74,7 +74,6 @@ def create_token(client, operator_id, admin_key):
     transaction.sign(client.operator_private_key)
     transaction.sign(admin_key)
 
-
     try:
         receipt = transaction.execute(client)
     except Exception as e:
@@ -111,15 +110,36 @@ def associate_token(client, recipient_id, recipient_private_key, token_id):
         print(f"Token association failed: {str(e)}")
         sys.exit(1)
 
-def transfer_token(client, recipient_id, token_id):
+def dissociate_token(client, recipient_id, recipient_private_key, token_id):
+    """Dissociate the specified token with the recipient account."""
+    transaction = (
+        TokenDissociateTransaction()
+        .set_account_id(recipient_id)
+        .add_token_id(token_id)
+        .freeze_with(client)
+    )
+    transaction.sign(client.operator_private_key) # sign with operator's key (payer)
+    transaction.sign(recipient_private_key) # sign with newly created account's key (recipient)
+
+    try:
+        receipt = transaction.execute(client)
+        if receipt.status != ResponseCode.SUCCESS:
+            status_message = ResponseCode.get_name(receipt.status)
+            raise Exception(f"Token dissociation failed with status: {status_message}")
+        print("Token dissociation successful.")
+    except Exception as e:
+        print(f"Token dissociation failed: {str(e)}")
+        sys.exit(1)
+
+def transfer_token(client, source_id, source_private_key, recipient_id, token_id):
     """Transfer the specified token to the recipient account."""
     transaction = (
         TransferTransaction()
-        .add_token_transfer(token_id, client.operator_account_id, -1)
+        .add_token_transfer(token_id, source_id, -1)
         .add_token_transfer(token_id, recipient_id, 1)
         .freeze_with(client)
     )
-    transaction.sign(client.operator_private_key)
+    transaction.sign(source_private_key)
 
     try:
         receipt = transaction.execute(client)
@@ -155,7 +175,6 @@ def create_topic(client):
 
     return topic_id
 
-
 def delete_token(client, token_id, admin_key):
     """Deletes the specified token on the Hedera network."""
     transaction = (
@@ -194,9 +213,19 @@ def main():
 
     recipient_id, recipient_private_key = create_new_account(client)
     token_id = create_token(client, operator_id, admin_key)
+
+    associate_token(client, recipient_id, recipient_private_key, token_id)
+    print(f"Token {token_id} successfully associated.")
+    transfer_token(client, operator_id, operator_key, recipient_id, token_id)
+    print(f"Token {token_id} successfully transferred in.")
+    transfer_token(client, recipient_id, recipient_private_key, operator_id, token_id)
+    print(f"Token {token_id} successfully transferred out.")
+    dissociate_token(client, recipient_id, recipient_private_key, token_id)
+    print(f"Token {token_id} successfully dissociated.")
     associate_token(client, recipient_id, recipient_private_key, token_id)
-    transfer_token(client, recipient_id, token_id)
-    delete_token(client, token_id, admin_key)
+    print(f"Token {token_id} successfully associated.")
+    delete_token(client, token_id, admin_key) 
+    print(f"Token {token_id} successfully deleted.")
 
     topic_id = create_topic(client)