hiero-sdk-python 0.0.2.dev3__py3-none-any.whl

hedera_sdk_python/timestamp.py

@@ -0,0 +1,166 @@
+from datetime import datetime, timedelta, timezone
+import random
+import time
+
+from hiero-sdk-python.hapi.services.timestamp_pb2 import Timestamp as TimestampProto
+
+
+class Timestamp:
+    """
+    Represents a specific moment in time with nanosecond precision.
+    """
+
+    MAX_NS = 1_000_000_000
+
+    def __init__(self, seconds: int, nanos: int):
+        """
+        Initialize a new `Timestamp` instance.
+
+        Args:
+            seconds (int): Number of seconds since epoch.
+            nanos (int): Number of nanoseconds past the last second.
+        """
+        self.seconds = seconds
+        self.nanos = nanos
+
+    @staticmethod
+    def generate(has_jitter=True) -> "Timestamp":
+        """
+        Generate a `Timestamp` with optional jitter.
+
+        Args:
+            has_jitter (bool): Whether to introduce random jitter. Default is True.
+
+        Returns:
+            Timestamp: A new `Timestamp` instance.
+        """
+        jitter = random.randint(3000, 8000) if has_jitter else 0
+        now_ms = int(round(time.time() * 1000)) - jitter
+        seconds = now_ms // 1000
+        nanos = (now_ms % 1000) * 1_000_000 + random.randint(0, 999_999)
+
+        return Timestamp(seconds, nanos)
+
+    @staticmethod
+    def from_date(date) -> "Timestamp":
+        """
+        Create a `Timestamp` from a Python `datetime` object, timestamp, or string.
+
+        Args:
+            date (datetime | int | str): A `datetime`, timestamp (int), or ISO 8601 string.
+
+        Returns:
+            Timestamp: A `Timestamp` instance.
+        """
+        if isinstance(date, datetime):
+            seconds = int(date.timestamp())
+            nanos = int((date.timestamp() % 1) * Timestamp.MAX_NS)
+        elif isinstance(date, int):
+            seconds = date
+            nanos = 0
+        elif isinstance(date, str):
+            parsed_date = datetime.fromisoformat(date)
+            seconds = int(parsed_date.timestamp())
+            nanos = int((parsed_date.timestamp() % 1) * Timestamp.MAX_NS)
+        else:
+            raise ValueError("Invalid type for 'date'. Must be datetime, int, or str.")
+
+        return Timestamp(seconds, nanos)
+
+    def to_date(self) -> datetime:
+        """
+        Convert the `Timestamp` to a Python `datetime` object.
+
+        Returns:
+            datetime: A `datetime` instance.
+        """
+        return datetime.fromtimestamp(self.seconds, tz=timezone.utc) + timedelta(
+            microseconds=self.nanos // 1000
+        )
+
+    def plus_nanos(self, nanos: int) -> "Timestamp":
+        """
+        Add nanoseconds to the current `Timestamp`.
+
+        Args:
+            nanos (int): The number of nanoseconds to add.
+
+        Returns:
+            Timestamp: A new `Timestamp` instance.
+        """
+        total_nanos = self.nanos + nanos
+        new_seconds = self.seconds + total_nanos // Timestamp.MAX_NS
+        new_nanos = total_nanos % Timestamp.MAX_NS
+
+        return Timestamp(new_seconds, new_nanos)
+
+    def to_protobuf(self) -> TimestampProto:
+        """
+        Convert the `Timestamp` to corresponding protobuf object.
+
+        Returns:
+            dict: A protobuf representation of the `Timestamp`.
+        """
+        return TimestampProto(seconds=self.seconds, nanos=self.nanos)
+
+    @staticmethod
+    def from_protobuf(pb_obj: TimestampProto) -> "Timestamp":
+        """
+        Create a `Timestamp` from a protobuf object.
+
+        Args:
+            pb_obj (timestamp_pb2.Timestamp): A protobuf Timestamp object.
+
+        Returns:
+            Timestamp: A `Timestamp` instance.
+        """
+
+        return Timestamp(pb_obj.seconds, pb_obj.nanos)
+
+    def __str__(self) -> str:
+        """
+        Get a string representation of the `Timestamp`.
+
+        Returns:
+            str: The string representation in the format `seconds.nanos`.
+        """
+        return f"{self.seconds}.{str(self.nanos).zfill(9)}"
+
+    def compare(self, other: "Timestamp") -> int:
+        """
+        Compare the current `Timestamp` with another.
+
+        Args:
+            other (Timestamp): The `Timestamp` to compare with.
+
+        Returns:
+            int: -1 if this `Timestamp` is earlier, 1 if later, 0 if equal.
+        """
+        if self.seconds != other.seconds:
+            return -1 if self.seconds < other.seconds else 1
+        if self.nanos != other.nanos:
+            return -1 if self.nanos < other.nanos else 1
+        return 0
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Check equality with another object.
+
+        Args:
+            other (object): The object to compare with.
+
+        Returns:
+            bool: True if equal, False otherwise.
+        """
+        if not isinstance(other, Timestamp):
+            return False
+        return self.seconds == other.seconds and self.nanos == other.nanos
+
+    def __hash__(self) -> int:
+        """
+        Get the hash value of the `Timestamp`.
+
+        Returns:
+            int: The hash value.
+        """
+        return hash((self.seconds, self.nanos))

hedera_sdk_python/tokens/token_associate_transaction.py

@@ -0,0 +1,85 @@
+from hiero-sdk-python.transaction.transaction import Transaction
+from hiero-sdk-python.hapi.services import token_associate_pb2
+from hiero-sdk-python.response_code import ResponseCode
+
+class TokenAssociateTransaction(Transaction):
+    """
+    Represents a token associate transaction on the Hedera network.
+
+    This transaction associates the specified tokens with an account,
+    allowing the account to hold and transact with those tokens.
+    
+    Inherits from the base Transaction class and implements the required methods
+    to build and execute a token association transaction.
+    """
+
+    def __init__(self, account_id=None, token_ids=None):
+        """
+        Initializes a new TokenAssociateTransaction instance with optional keyword arguments.
+
+        Args:
+            account_id (AccountId, optional): The account to associate tokens with.
+            token_ids (list of TokenId, optional): The tokens to associate with the account.
+        """
+        super().__init__()
+        self.account_id = account_id
+        self.token_ids = token_ids or []
+
+        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 association.
+
+        Returns:
+            TransactionBody: The protobuf transaction body containing the token association 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_associate_body = token_associate_pb2.TokenAssociateTransactionBody(
+            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.tokenAssociate.CopyFrom(token_associate_body)
+
+        return transaction_body
+
+    def _execute_transaction(self, client, transaction_proto):
+        """
+        Executes the token association 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.associateTokens(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

hedera_sdk_python/tokens/token_create_transaction.py

@@ -0,0 +1,144 @@
+from hiero-sdk-python.transaction.transaction import Transaction
+from hiero-sdk-python.hapi.services import token_create_pb2, basic_types_pb2
+from hiero-sdk-python.response_code import ResponseCode
+from cryptography.hazmat.primitives import serialization
+
+class TokenCreateTransaction(Transaction):
+    """
+    Represents a token creation transaction on the Hedera network.
+
+    This transaction creates a new token with specified properties, such as
+    name, symbol, decimals, initial supply, and treasury account.
+    
+    Inherits from the base Transaction class and implements the required methods
+    to build and execute a token creation transaction.
+    """
+
+    def __init__(self, token_name=None, token_symbol=None, decimals=None, initial_supply=None, 
+                 treasury_account_id=None, admin_key=None, supply_key=None):
+        """
+        Initializes a new TokenCreateTransaction instance with optional keyword arguments.
+
+        Args:
+            token_name (str, optional): The name of the token.
+            token_symbol (str, optional): The symbol of the token.
+            decimals (int, optional): The number of decimals for the token.
+            initial_supply (int, optional): The initial supply of the token.
+            treasury_account_id (AccountId, optional): The treasury account ID.
+            admin_key (PrivateKey, optional): The admin key for the token.
+            supply_key (PrivateKey, optional): The supply key for the token.
+
+        """
+        super().__init__()
+        self.token_name = token_name
+        self.token_symbol = token_symbol
+        self.decimals = decimals
+        self.initial_supply = initial_supply
+        self.treasury_account_id = treasury_account_id
+        self.admin_key = admin_key
+        self.supply_key = supply_key
+
+        self._default_transaction_fee = 3_000_000_000
+
+    def set_token_name(self, name):
+        self._require_not_frozen()
+        self.token_name = name
+        return self
+
+    def set_token_symbol(self, symbol):
+        self._require_not_frozen()
+        self.token_symbol = symbol
+        return self
+
+    def set_decimals(self, decimals):
+        self._require_not_frozen()
+        self.decimals = decimals
+        return self
+
+    def set_initial_supply(self, initial_supply):
+        self._require_not_frozen()
+        self.initial_supply = initial_supply
+        return self
+
+    def set_treasury_account_id(self, account_id):
+        self._require_not_frozen()
+        self.treasury_account_id = account_id
+        return self
+
+    def set_admin_key(self, admin_key): 
+        self._require_not_frozen()
+        self.admin_key = admin_key
+        return self
+    
+    def set_supply_key(self, supply_key): 
+        self._require_not_frozen()
+        self.supply_key = supply_key
+        return self
+    
+    def build_transaction_body(self):
+        """
+        Builds and returns the protobuf transaction body for token creation.
+
+        Returns:
+            TransactionBody: The protobuf transaction body containing the token creation details.
+
+        Raises:
+            ValueError: If required fields are missing.
+        """
+        if not all([
+            self.token_name,
+            self.token_symbol,
+            self.decimals is not None,
+            self.initial_supply is not None,
+            self.treasury_account_id
+        ]):
+            raise ValueError("Missing required fields")
+
+        admin_key_proto = None
+        if self.admin_key:
+            admin_public_key_bytes = self.admin_key.public_key().to_bytes_raw()
+            admin_key_proto = basic_types_pb2.Key(ed25519=admin_public_key_bytes)
+
+        supply_key_proto = None
+        if self.supply_key:
+            supply_public_key_bytes = self.supply_key.public_key().to_bytes_raw()
+            supply_key_proto = basic_types_pb2.Key(ed25519=supply_public_key_bytes)
+
+        token_create_body = token_create_pb2.TokenCreateTransactionBody(
+            name=self.token_name,
+            symbol=self.token_symbol,
+            decimals=self.decimals,
+            initialSupply=self.initial_supply,
+            treasury=self.treasury_account_id.to_proto(),
+            adminKey=admin_key_proto,
+            supplyKey=supply_key_proto
+        )
+
+        transaction_body = self.build_base_transaction_body()
+        transaction_body.tokenCreation.CopyFrom(token_create_body)
+
+        return transaction_body
+
+    def _execute_transaction(self, client, transaction_proto):
+        """
+        Executes the token creation 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.createToken(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

hedera_sdk_python/tokens/token_delete_transaction.py

@@ -0,0 +1,84 @@
+from hiero-sdk-python.transaction.transaction import Transaction
+from hiero-sdk-python.hapi.services import token_delete_pb2
+from hiero-sdk-python.response_code import ResponseCode
+
+class TokenDeleteTransaction(Transaction):
+    """
+    Represents a token deletion transaction on the Hedera network.
+
+    This transaction deletes a specified token, rendering it inactive.
+
+    Inherits from the base Transaction class and implements the required methods
+    to build and execute a token deletion transaction.
+    """
+
+    def __init__(self, token_id=None):
+        """
+        Initializes a new TokenDeleteTransaction instance with optional token_id.
+
+        Args:
+            token_id (TokenId, optional): The ID of the token to be deleted.
+        """
+        super().__init__()
+        self.token_id = token_id
+        self._default_transaction_fee = 3_000_000_000
+
+    def set_token_id(self, token_id):
+        """
+        Sets the ID of the token to be deleted.
+
+        Args:
+            token_id (TokenId): The ID of the token to be deleted.
+
+        Returns:
+            TokenDeleteTransaction: Returns self for method chaining.
+        """
+        self._require_not_frozen()
+        self.token_id = token_id
+        return self
+
+    def build_transaction_body(self):
+        """
+        Builds and returns the protobuf transaction body for token deletion.
+
+        Returns:
+            TransactionBody: The protobuf transaction body containing the token deletion details.
+
+        Raises:
+            ValueError: If the token ID is missing.
+        """
+        if not self.token_id:
+            raise ValueError("Missing required TokenID.")
+
+        token_delete_body = token_delete_pb2.TokenDeleteTransactionBody(
+            token=self.token_id.to_proto()
+        )
+
+        transaction_body = self.build_base_transaction_body()
+        transaction_body.tokenDeletion.CopyFrom(token_delete_body)
+
+        return transaction_body
+
+    def _execute_transaction(self, client, transaction_proto):
+        """
+        Executes the token deletion 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.deleteToken(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

hedera_sdk_python/tokens/token_dissociate_transaction.py

@@ -0,0 +1,81 @@
+from hiero-sdk-python.transaction.transaction import Transaction
+from hiero-sdk-python.hapi.services import token_dissociate_pb2
+from hiero-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, account_id=None, token_ids=None):
+        """
+        Initializes a new TokenDissociateTransaction instance with default values.
+        """
+        super().__init__()
+        self.account_id = account_id
+        self.token_ids = token_ids or []
+
+        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

hedera_sdk_python/tokens/token_id.py

@@ -0,0 +1,44 @@
+from hiero-sdk-python.hapi.services import basic_types_pb2
+
+class TokenId:
+    def __init__(self, shard=0, realm=0, num=0):
+        self.shard = shard
+        self.realm = realm
+        self.num = num
+
+    @classmethod
+    def from_proto(cls, token_id_proto):
+        """
+        Creates a TokenId instance from a protobuf TokenID object.
+        """
+        return cls(
+            shard=token_id_proto.shardNum,
+            realm=token_id_proto.realmNum,
+            num=token_id_proto.tokenNum
+        )
+
+    def to_proto(self):
+        """
+        Converts the TokenId instance to a protobuf TokenID object.
+        """
+        token_id_proto = basic_types_pb2.TokenID()
+        token_id_proto.shardNum = self.shard
+        token_id_proto.realmNum = self.realm
+        token_id_proto.tokenNum = self.num
+        return token_id_proto
+
+    def __str__(self):
+        """
+        Returns the string representation of the TokenId in the format 'shard.realm.num'.
+        """
+        return f"{self.shard}.{self.realm}.{self.num}"
+
+    @classmethod
+    def from_string(cls, token_id_str):
+        """
+        Parses a string in the format 'shard.realm.num' to create a TokenId instance.
+        """
+        parts = token_id_str.strip().split('.')
+        if len(parts) != 3:
+            raise ValueError("Invalid TokenId format. Expected 'shard.realm.num'")
+        return cls(shard=int(parts[0]), realm=int(parts[1]), num=int(parts[2]))