feat: NFTTokenCreateTransaction

feat: NFTTokenCreateTransaction

feat: NFTTokenCreateTransaction

local tests passed

fix: supply type enum

fix: supply type enum error

fix: supply type default as infinite

fix: duplicate imports

Author: exploreriii

examples/README.md

@@ -85,9 +85,11 @@ transaction = TokenCreateTransaction(
     token_params=TokenParams(
         token_name="ExampleToken",
         token_symbol="EXT",
-        decimals=2, # 0 for NON_FUNGIBLE_UNIQUE
-        initial_supply=1000,  # 0 for NON_FUNGIBLE_UNIQUE
+        decimals=2,                            # 0 for NON_FUNGIBLE_UNIQUE
+        initial_supply=1000,                   # 0 for NON_FUNGIBLE_UNIQUE
         token_type=TokenType.FUNGIBLE_COMMON,  # or TokenType.NON_FUNGIBLE_UNIQUE
+        max_supply=1000                        # Must be 0 for INFINITE
+        supply_type=SupplyType.FINITE,         # or SupplyType.INFINITE
         freeze_default=False,
         treasury_account_id=operator_id
     ),
@@ -108,9 +110,11 @@ transaction = (
     TokenCreateTransaction()  # no params => uses default placeholders which are next overwritten.
     .set_token_name("ExampleToken")
     .set_token_symbol("EXT")
-    .set_decimals(2) # 0 for NON_FUNGIBLE_UNIQUE
-    .set_initial_supply(1000) # 0 for NON_FUNGIBLE_UNIQUE
-    .set_token_type(TokenType.FUNGIBLE_COMMON) # or TokenType.NON_FUNGIBLE_UNIQUE
+    .set_decimals(2)                            # 0 for NON_FUNGIBLE_UNIQUE
+    .set_initial_supply(1000)                   # 0 for NON_FUNGIBLE_UNIQUE
+    .set_token_type(TokenType.FUNGIBLE_COMMON)  # or TokenType.NON_FUNGIBLE_UNIQUE
+    .set_max_supply(1000)                       # Must be 0 for INFINITE
+    .set_supply_type(SupplyType.FINITE)         # or SupplyType.INFINITE
     .set_freeze_default(False)
     .set_treasury_account_id(operator_id)
     .set_admin_key(admin_key)       # added but optional. Necessary for Token Delete or Update.
@@ -352,7 +356,7 @@ transaction.execute(client)
     transaction.execute(client)
 ```
 #### Method Chaining:
-```
+``` 
 transaction = (
     TopicCreateTransaction()
     .set_memo("My Super Topic Memo")

examples/token_create.py

@@ -25,7 +25,8 @@
     PrivateKey,
     TokenCreateTransaction,
     Network,
-    TokenType
+    TokenType,
+    SupplyType
     )
 
 # Load environment variables from .env file
@@ -60,6 +61,8 @@ def create_token():
         .set_initial_supply(10) # 0 for NON_FUNGIBLE_UNIQUE
         .set_treasury_account_id(operator_id) # Also known as treasury account
         .set_token_type(TokenType.FUNGIBLE_COMMON) # or TokenType.NON_FUNGIBLE_UNIQUE
+        .set_token_type(SupplyType.FINITE) # or SupplyType.INFINITE
+        .set_max_supply(100)
         .set_admin_key(admin_key) # Optional
         .set_supply_key(supply_key) # Optional
         .set_freeze_key(freeze_key) # Optional

src/hiero_sdk_python/tokens/supply_type.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class SupplyType(Enum):
+    INFINITE = 0
+    FINITE = 1

src/hiero_sdk_python/tokens/token_create_transaction.py

@@ -15,6 +15,7 @@
 from hiero_sdk_python.hapi.services import token_create_pb2, basic_types_pb2
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.token_type import TokenType
+from hiero_sdk_python.tokens.supply_type import SupplyType
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.crypto.private_key import PrivateKey
 
@@ -25,14 +26,15 @@ class TokenCreateValidator:
     """Token, key and freeze checks for creating a token as per the proto"""
 
     @staticmethod
-    def validate_token_params(token_params):
+    def _validate_token_params(token_params):
         """
         Ensure valid values for the token characteristics.
         """
         TokenCreateValidator._validate_required_fields(token_params)
         TokenCreateValidator._validate_name_and_symbol(token_params)
         TokenCreateValidator._validate_initial_supply(token_params)
         TokenCreateValidator._validate_decimals_and_token_type(token_params)
+        TokenCreateValidator._validate_supply_max_and_type(token_params)
 
     @staticmethod
     def _validate_required_fields(token_params):
@@ -70,15 +72,18 @@ def _validate_initial_supply(token_params):
         """
         Ensure initial supply is a non-negative integer and does not exceed max supply.
         """
-        MAX_SUPPLY = 9_223_372_036_854_775_807  # 2^63 - 1
+        MAXIMUM_SUPPLY = 9_223_372_036_854_775_807  # 2^63 - 1
 
         if (
             not isinstance(token_params.initial_supply, int)
             or token_params.initial_supply < 0
         ):
             raise ValueError("Initial supply must be a non-negative integer")
-        if token_params.initial_supply > MAX_SUPPLY:
-            raise ValueError(f"Initial supply cannot exceed {MAX_SUPPLY}")
+        if token_params.initial_supply > MAXIMUM_SUPPLY:
+            raise ValueError(f"Initial supply cannot exceed {MAXIMUM_SUPPLY}")
+        if token_params.max_supply > MAXIMUM_SUPPLY:
+            raise ValueError(f"Max supply cannot exceed {MAXIMUM_SUPPLY}")
+
 
     @staticmethod
     def _validate_decimals_and_token_type(token_params):
@@ -101,7 +106,7 @@ def _validate_decimals_and_token_type(token_params):
                 raise ValueError("A Non-fungible Unique Token requires an initial supply of zero")
 
     @staticmethod
-    def validate_token_freeze_status(keys, token_params):
+    def _validate_token_freeze_status(keys, token_params):
         """Ensure account is not frozen for this token."""
         if token_params.freeze_default:
             if not keys.freeze_key:
@@ -112,6 +117,27 @@ def validate_token_freeze_status(keys, token_params):
                 "Token frozen. Please complete a Token Unfreeze Transaction."
             )
 
+    @staticmethod
+    def _validate_supply_max_and_type(token_params):
+        """Ensure max supply and supply type constraints."""
+        # An infinite token must have max supply = 0.
+        # A finite token must have max supply > 0.
+        if token_params.max_supply != 0: # Setting a max supply is only approprite for a finite token.
+            if token_params.supply_type != SupplyType.FINITE: 
+                raise ValueError("Setting a max supply field requires setting a finite supply type")
+
+        # Finite tokens have the option to set a max supply >0.
+        # A finite token must have max supply > 0.
+        if token_params.supply_type == SupplyType.FINITE:
+            if token_params.max_supply <= 0:
+                raise ValueError("A finite supply token requires max_supply greater than zero 0")
+
+            # Ensure max supply is greater than initial supply
+            if token_params.initial_supply > token_params.max_supply:
+                raise ValueError(
+                    "Initial supply cannot exceed the defined max supply for a finite token"
+                )
+
 @dataclass
 class TokenParams:
     """
@@ -124,6 +150,8 @@ class TokenParams:
         decimals (optional): The number of decimals for the token. This must be zero for NFTs.
         initial_supply (optional): The initial supply of the token.
         token_type (optional): The type of the token, defaulting to fungible.
+        max_supply (optional): The maximum number of fungible tokens or NFT serial numbers that can be in circulation.
+        supply_type (optional): The token supply status as finite or infinite.
         freeze_default (optional): An initial Freeze status for accounts associated to this token.
     """
 
@@ -133,6 +161,8 @@ class TokenParams:
     decimals: int = 0  # Default to zero decimals
     initial_supply: int = 0  # Default to zero initial supply
     token_type: TokenType = TokenType.FUNGIBLE_COMMON  # Default to Fungible Common
+    max_supply: int = 0 # Since defaulting to infinite
+    supply_type: SupplyType = SupplyType.INFINITE # Default to infinite
     freeze_default: bool = False
 
 
@@ -192,6 +222,8 @@ def __init__(self, token_params=None, keys=None):
                 decimals=0,
                 initial_supply=0,
                 token_type=TokenType.FUNGIBLE_COMMON,
+                max_supply=0,
+                supply_type=SupplyType.INFINITE,
                 freeze_default=False
             )
 
@@ -200,7 +232,6 @@ def __init__(self, token_params=None, keys=None):
         self._keys = keys if keys else TokenKeys()
 
         self._default_transaction_fee = DEFAULT_TRANSACTION_FEE
-        self._is_frozen = False
 
     def set_token_params(self, token_params):
         """
@@ -231,6 +262,11 @@ def set_token_symbol(self, symbol):
         self._token_params.token_symbol = symbol
         return self
 
+    def set_treasury_account_id(self, account_id):
+        self._require_not_frozen()
+        self._token_params.treasury_account_id = account_id
+        return self
+    
     def set_decimals(self, decimals):
         self._require_not_frozen()
         self._token_params.decimals = decimals
@@ -245,11 +281,21 @@ def set_token_type(self, token_type):
         self._require_not_frozen()
         self._token_params.token_type = token_type
         return self
+    
+    def set_max_supply(self, max_supply):
+        self._require_not_frozen()
+        self._token_params.max_supply = max_supply
+        return self
 
-    def set_treasury_account_id(self, account_id):
+    def set_supply_type(self, supply_type):
         self._require_not_frozen()
-        self._token_params.treasury_account_id = account_id
+        self._token_params.supply_type = supply_type
         return self
+    
+    def set_freeze_default(self, freeze_default):
+        self._require_not_frozen()
+        self._token_params.freeze_default = freeze_default
+        return self    
 
     def set_admin_key(self, key):
         self._require_not_frozen()
@@ -266,17 +312,6 @@ def set_freeze_key(self, key):
         self._keys.freeze_key = key
         return self
 
-    def freeze(self):
-        """Marks the transaction as frozen to prevent further modifications."""
-        self._is_frozen = True
-
-    def _require_not_frozen(self):
-        """
-        Helper method ensuring no changes are made after freeze() has been called.
-        """
-        if self._is_frozen:
-            raise ValueError("Transaction is frozen and cannot be modified.")
-
     def build_transaction_body(self):
         """
         Builds and returns the protobuf transaction body for token creation.
@@ -289,10 +324,10 @@ def build_transaction_body(self):
         """
 
         # Validate all token params
-        TokenCreateValidator.validate_token_params(self._token_params)
+        TokenCreateValidator._validate_token_params(self._token_params)
 
         # Validate freeze status
-        TokenCreateValidator.validate_token_freeze_status(self._keys, self._token_params)
+        TokenCreateValidator._validate_token_freeze_status(self._keys, self._token_params)
 
         admin_key_proto = None
         if self._keys.admin_key:
@@ -318,13 +353,24 @@ def build_transaction_body(self):
         else:
             token_type_value = self._token_params.token_type
 
+        # Ensure supply type is correctly set with default to infinite
+        if self._token_params.supply_type is None:
+            supply_type_value = 0  # default INFINITE
+        elif isinstance(self._token_params.supply_type, SupplyType):
+            supply_type_value = self._token_params.supply_type.value
+        else:
+            supply_type_value = self._token_params.supply_type
+
         # Construct the TokenCreateTransactionBody
         token_create_body = token_create_pb2.TokenCreateTransactionBody(
             name=self._token_params.token_name,
             symbol=self._token_params.token_symbol,
             decimals=self._token_params.decimals,
             initialSupply=self._token_params.initial_supply,
             tokenType=token_type_value,
+            supplyType=supply_type_value,
+            maxSupply=self._token_params.max_supply,
+            freezeDefault=self._token_params.freeze_default,
             treasury=self._token_params.treasury_account_id.to_proto(),
             adminKey=admin_key_proto,
             supplyKey=supply_key_proto,
@@ -358,25 +404,5 @@ def _execute_transaction(self, client, transaction_proto):
             raise Exception(f"Error during transaction submission: {error_code} ({error_message})")
 
         receipt = self.get_receipt(client)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
         return receipt
 

test.py

@@ -36,6 +36,7 @@
 
 # Token-related imports
 from hiero_sdk_python.tokens.token_type import TokenType
+from hiero_sdk_python.tokens.supply_type import SupplyType
 from hiero_sdk_python.tokens.token_create_transaction import (
     TokenCreateTransaction,
     TokenParams,
@@ -125,6 +126,8 @@ def create_fungible_token(client, operator_id, admin_key, supply_key, freeze_key
         initial_supply=1000,
         treasury_account_id=operator_id,
         token_type=TokenType.FUNGIBLE_COMMON,
+        supply_type=SupplyType.FINITE,
+        max_supply=10000  
     )
 
     # Creating TokenKeys
@@ -170,6 +173,8 @@ def create_nft_token(client, operator_id, admin_key, supply_key, freeze_key):
         initial_supply=0,
         treasury_account_id=operator_id,
         token_type=TokenType.NON_FUNGIBLE_UNIQUE,
+        supply_type=SupplyType.FINITE,
+        max_supply=10_000  
     )
 
     # Creating TokenKeys

tests/test_supply_type.py

@@ -0,0 +1,16 @@
+import pytest
+from hiero_sdk_python.tokens.supply_type import SupplyType
+
+def test_members():
+    assert SupplyType.INFINITE.value == 0
+    assert SupplyType.FINITE.value == 1
+
+def test_name():
+    assert SupplyType.INFINITE.name == "INFINITE"
+    assert SupplyType.FINITE.name == "FINITE"
+
+def test_supply_type_enum_members():
+    members = list(SupplyType)
+    assert len(members) == 2
+    assert SupplyType.INFINITE in members
+    assert SupplyType.FINITE in members