TokenDissociateTransaction

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,6 +9,7 @@
 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
@@ -111,6 +112,28 @@ def associate_token(client, recipient_id, recipient_private_key, token_id):
         print(f"Token association failed: {str(e)}")
         sys.exit(1)
 
+
+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, recipient_id, token_id):
     """Transfer the specified token to the recipient account."""
     transaction = (
@@ -195,6 +218,7 @@ 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)
+    dissociate_token(client, recipient_id, recipient_private_key, token_id)
     transfer_token(client, recipient_id, token_id)
     delete_token(client, token_id, admin_key)
 

tests/test_token_dissociate_transaction.py

@@ -0,0 +1,89 @@
+import pytest
+from unittest.mock import MagicMock
+from hedera_sdk_python.tokens.token_dissociate_transaction import TokenDissociateTransaction
+from hedera_sdk_python.hapi import timestamp_pb2
+from hedera_sdk_python.transaction.transaction_id import TransactionId
+
+def generate_transaction_id(account_id_proto):
+    """Generate a unique transaction ID based on the account ID and the current timestamp."""
+    import time
+    current_time = time.time()
+    timestamp_seconds = int(current_time)
+    timestamp_nanos = int((current_time - timestamp_seconds) * 1e9)
+
+    tx_timestamp = timestamp_pb2.Timestamp(seconds=timestamp_seconds, nanos=timestamp_nanos)
+
+    tx_id = TransactionId(
+        valid_start=tx_timestamp,
+        account_id=account_id_proto
+    )
+    return tx_id
+
+def test_build_transaction_body(mock_account_ids):
+    """Test building the token dissociate transaction body with valid account ID and token IDs."""
+    account_id, _, node_account_id, token_id_1, token_id_2 = mock_account_ids
+    dissociate_tx = TokenDissociateTransaction()
+
+    dissociate_tx.set_account_id(account_id)
+    dissociate_tx.add_token_id(token_id_1)
+    dissociate_tx.add_token_id(token_id_2)
+    dissociate_tx.transaction_id = generate_transaction_id(account_id)
+    dissociate_tx.node_account_id = node_account_id
+
+    transaction_body = dissociate_tx.build_transaction_body()
+
+    assert transaction_body.tokenDissociate.account.shardNum == account_id.shard
+    assert transaction_body.tokenDissociate.account.realmNum == account_id.realm
+    assert transaction_body.tokenDissociate.account.accountNum == account_id.num
+    assert len(transaction_body.tokenDissociate.tokens) == 2
+    assert transaction_body.tokenDissociate.tokens[0].tokenNum == token_id_1.num
+    assert transaction_body.tokenDissociate.tokens[1].tokenNum == token_id_2.num
+
+
+def test_missing_fields():
+    """Test that building the transaction without account ID or token IDs raises a ValueError."""
+    dissociate_tx = TokenDissociateTransaction()
+
+    with pytest.raises(ValueError, match="Account ID and token IDs must be set."):
+        dissociate_tx.build_transaction_body()
+
+def test_sign_transaction(mock_account_ids):
+    """Test signing the token dissociate transaction with a private key."""
+    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    dissociate_tx = TokenDissociateTransaction()
+    dissociate_tx.set_account_id(account_id)
+    dissociate_tx.add_token_id(token_id_1)
+    dissociate_tx.transaction_id = generate_transaction_id(account_id)
+    dissociate_tx.node_account_id = node_account_id
+
+    private_key = MagicMock()
+    private_key.sign.return_value = b'signature'
+    private_key.public_key().public_bytes.return_value = b'public_key'
+
+    dissociate_tx.sign(private_key)
+
+    assert len(dissociate_tx.signature_map.sigPair) == 1
+    sig_pair = dissociate_tx.signature_map.sigPair[0]
+
+    assert sig_pair.pubKeyPrefix == b'public_key'  
+    assert sig_pair.ed25519 == b'signature'
+
+
+def test_to_proto(mock_account_ids):
+    """Test converting the token dissociate transaction to protobuf format after signing."""
+    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    dissociate_tx = TokenDissociateTransaction()
+    dissociate_tx.set_account_id(account_id)
+    dissociate_tx.add_token_id(token_id_1)
+    dissociate_tx.transaction_id = generate_transaction_id(account_id)
+    dissociate_tx.node_account_id = node_account_id
+
+    private_key = MagicMock()
+    private_key.sign.return_value = b'signature'
+    private_key.public_key().public_bytes.return_value = b'public_key'
+
+    dissociate_tx.sign(private_key)
+    proto = dissociate_tx.to_proto()
+
+    assert proto.signedTransactionBytes
+    assert len(proto.signedTransactionBytes) > 0