admin_key private public user-friendly and docs

Author: exploreriii

README.md

@@ -109,6 +109,7 @@ transaction = (
         .freeze_with(client)
     )
 
+    transaction.sign(admin_key)
     transaction.sign(operator_key)
     transaction.execute(client)
 ```
@@ -148,9 +149,10 @@ transaction = (
         TokenDeleteTransaction()
         .set_token_id(token_id)
         .freeze_with(client)
-        .sign(operator_key)
     )
+
     transaction.sign(admin_key)
+    transaction.sign(operator_key)
     transaction.execute(client)
 ```
 

examples/token_create.py

@@ -10,6 +10,7 @@
 from src.crypto.private_key import PrivateKey
 from src.tokens.token_create_transaction import TokenCreateTransaction
 from src.client.network import Network
+from cryptography.hazmat.primitives import serialization
 
 load_dotenv()
 
@@ -20,7 +21,7 @@ def create_token():
     operator_id = AccountId.from_string(os.getenv('OPERATOR_ID'))
     operator_key = PrivateKey.from_string(os.getenv('OPERATOR_KEY'))
     admin_key = PrivateKey.from_string(os.getenv('ADMIN_KEY'))
-
+    
     client.set_operator(operator_id, operator_key)
 
     transaction = (
@@ -33,8 +34,9 @@ def create_token():
         .set_admin_key(admin_key)
         .freeze_with(client)
         .sign(operator_key)
+        .sign(admin_key)
     )
-
+    
     try:
         receipt = transaction.execute(client)
         if receipt and receipt.tokenId:

src/tokens/token_create_transaction.py

@@ -2,6 +2,7 @@
 from src.proto import token_create_pb2
 from src.response_code import ResponseCode
 from src.proto import basic_types_pb2
+from cryptography.hazmat.primitives import serialization
 
 class TokenCreateTransaction(Transaction):
     """
@@ -77,17 +78,21 @@ def build_transaction_body(self):
         ]):
             raise ValueError("Missing required fields")
 
-        key = basic_types_pb2.Key(
-            ed25519=self.admin_key if self.admin_key else None
-        )
+        admin_key_proto = None
+        if self.admin_key:
+            admin_public_key_bytes = self.admin_key.public_key().public_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+            admin_key_proto = basic_types_pb2.Key(ed25519=admin_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=key if self.admin_key else None
+            adminKey=admin_key_proto
         )
 
         transaction_body = self.build_base_transaction_body()

test.py

@@ -5,13 +5,11 @@
 from src.account.account_id import AccountId
 from src.account.account_create_transaction import AccountCreateTransaction
 from src.crypto.private_key import PrivateKey
-from src.crypto.public_key import PublicKey
 from src.tokens.token_create_transaction import TokenCreateTransaction
 from src.tokens.token_associate_transaction import TokenAssociateTransaction
 from src.transaction.transfer_transaction import TransferTransaction
 from src.response_code import ResponseCode
 from src.tokens.token_delete_transaction import TokenDeleteTransaction
-from cryptography.hazmat.primitives import serialization
 
 def load_operator_credentials():
     """Load operator credentials from environment variables."""
@@ -56,18 +54,15 @@ def create_new_account(client, initial_balance=100000000):
 
 def create_token(client, operator_id, admin_key):
     """Create a new token and return its TokenId instance."""
-    admin_public_key_bytes = admin_key.public_key().public_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PublicFormat.Raw
-    )    
+
     transaction = (
         TokenCreateTransaction()
         .set_token_name("ExampleToken")
         .set_token_symbol("EXT")
         .set_decimals(2)
         .set_initial_supply(1000)
         .set_treasury_account_id(operator_id)
-        .set_admin_key(admin_public_key_bytes)
+        .set_admin_key(admin_key)
         .freeze_with(client)
     )
     transaction.sign(admin_key)

tests/conftest.py

@@ -1,6 +1,8 @@
 import pytest
 from src.account.account_id import AccountId
 from src.tokens.token_id import TokenId
+from src.crypto.private_key import PrivateKey
+from cryptography.hazmat.primitives import serialization
 
 @pytest.fixture
 def mock_account_ids():
@@ -11,3 +13,14 @@ def mock_account_ids():
     token_id_1 = TokenId(1, 1, 1)
     token_id_2 = TokenId(2, 2, 2)
     return account_id_sender, account_id_recipient, node_account_id, token_id_1, token_id_2
+
+@pytest.fixture
+def admin_key():
+    admin_key = PrivateKey.generate()
+
+    admin_public_key_bytes = admin_key.public_key().public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw
+    )
+
+    return admin_key, admin_public_key_bytes

tests/test_token_create_transaction.py

@@ -3,6 +3,8 @@
 from src.tokens.token_create_transaction import TokenCreateTransaction
 from src.proto import basic_types_pb2, timestamp_pb2
 from src.transaction.transaction_id import TransactionId
+from src.proto import transaction_pb2, transaction_body_pb2
+from cryptography.hazmat.primitives import serialization
 
 def generate_transaction_id(account_id_proto):
     """Generate a unique transaction ID based on the account ID and the current timestamp."""
@@ -19,7 +21,28 @@ def generate_transaction_id(account_id_proto):
     )
     return tx_id
 
-def test_build_transaction_body(mock_account_ids):
+def test_build_transaction_body_without_admin_key(mock_account_ids):
+    """Test building a token creation transaction body without an admin key."""
+    treasury_account, _, node_account_id, _, _ = mock_account_ids
+
+    token_tx = TokenCreateTransaction()
+    token_tx.set_token_name("MyToken")
+    token_tx.set_token_symbol("MTK")
+    token_tx.set_decimals(2)
+    token_tx.set_initial_supply(1000)
+    token_tx.set_treasury_account_id(treasury_account)
+    token_tx.transaction_id = generate_transaction_id(treasury_account)
+    token_tx.node_account_id = node_account_id
+
+    transaction_body = token_tx.build_transaction_body()
+
+    assert transaction_body.tokenCreation.name == "MyToken"
+    assert transaction_body.tokenCreation.symbol == "MTK"
+    assert transaction_body.tokenCreation.decimals == 2
+    assert transaction_body.tokenCreation.initialSupply == 1000
+    assert not transaction_body.tokenCreation.HasField("adminKey")
+
+def test_build_transaction_body(mock_account_ids, admin_key):
     """Test building a token creation transaction body with valid values."""
     treasury_account, _, node_account_id, _, _ = mock_account_ids
 
@@ -30,6 +53,7 @@ def test_build_transaction_body(mock_account_ids):
     token_tx.set_initial_supply(1000)
     token_tx.set_treasury_account_id(treasury_account)
     token_tx.transaction_id = generate_transaction_id(treasury_account)
+    token_tx.set_admin_key(admin_key[0])
     token_tx.node_account_id = node_account_id
 
     transaction_body = token_tx.build_transaction_body()
@@ -38,6 +62,7 @@ def test_build_transaction_body(mock_account_ids):
     assert transaction_body.tokenCreation.symbol == "MTK"
     assert transaction_body.tokenCreation.decimals == 2
     assert transaction_body.tokenCreation.initialSupply == 1000
+    assert transaction_body.tokenCreation.adminKey.ed25519 == admin_key[1]
 
 def test_missing_fields():
     """Test that building a transaction without required fields raises a ValueError."""
@@ -48,6 +73,7 @@ def test_missing_fields():
 def test_sign_transaction(mock_account_ids):
     """Test signing the token creation transaction with a private key."""
     treasury_account, _, node_account_id, _, _ = mock_account_ids
+
     token_tx = TokenCreateTransaction()
     token_tx.set_token_name("MyToken")
     token_tx.set_token_symbol("MTK")
@@ -61,32 +87,79 @@ def test_sign_transaction(mock_account_ids):
     private_key.sign.return_value = b'signature'
     private_key.public_key().public_bytes.return_value = b'public_key'
 
+    private_key_admin = MagicMock()
+    private_key_admin.sign.return_value = b'admin_signature'
+    private_key_admin.public_key().public_bytes.return_value = b'admin_public_key'
+
     token_tx.sign(private_key)
+    token_tx.sign(private_key_admin)
+
+    assert len(token_tx.signature_map.sigPair) == 2
 
-    assert len(token_tx.signature_map.sigPair) == 1
     sig_pair = token_tx.signature_map.sigPair[0]
     assert sig_pair.pubKeyPrefix == b'public_key' 
     assert sig_pair.ed25519 == b'signature'
 
+    sig_pair_admin = token_tx.signature_map.sigPair[1]
+    assert sig_pair_admin.pubKeyPrefix == b'admin_public_key'
+    assert sig_pair_admin.ed25519 == b'admin_signature'
 
-def test_to_proto(mock_account_ids):
+def test_to_proto_without_admin_key(mock_account_ids):
+    """Test protobuf conversion when admin key is not set."""
+    treasury_account, _, node_account_id, _, _ = mock_account_ids
+
+    token_tx = TokenCreateTransaction()
+    token_tx.set_token_name("MyToken")
+    token_tx.set_token_symbol("MTK")
+    token_tx.set_decimals(2)
+    token_tx.set_initial_supply(1000)
+    token_tx.set_treasury_account_id(treasury_account)
+    token_tx.transaction_id = generate_transaction_id(treasury_account)
+    token_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'
+
+    token_tx.sign(private_key)
+    proto = token_tx.to_proto()
+
+    assert len(proto.signedTransactionBytes) > 0
+
+    transaction = transaction_pb2.Transaction.FromString(proto.signedTransactionBytes)
+    transaction_body = transaction_body_pb2.TransactionBody.FromString(transaction.bodyBytes)
+
+    assert not transaction_body.tokenCreation.HasField("adminKey")
+
+def test_to_proto(mock_account_ids, admin_key):
     """Test converting the token creation transaction to protobuf format after signing."""
     treasury_account, _, node_account_id, _, _ = mock_account_ids
+
     token_tx = TokenCreateTransaction()
     token_tx.set_token_name("MyToken")
     token_tx.set_token_symbol("MTK")
     token_tx.set_decimals(2)
     token_tx.set_initial_supply(1000)
     token_tx.set_treasury_account_id(treasury_account)
+    token_tx.set_admin_key(admin_key[0])
     token_tx.transaction_id = generate_transaction_id(treasury_account)
     token_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'
 
+    private_key_admin = MagicMock()
+    private_key_admin.sign.return_value = b'admin_signature'
+    private_key_admin.public_key().public_bytes.return_value = b'admin_public_key'
+
     token_tx.sign(private_key)
+    token_tx.sign(private_key_admin)
     proto = token_tx.to_proto()
 
-    assert proto.signedTransactionBytes
     assert len(proto.signedTransactionBytes) > 0
+
+    transaction = transaction_pb2.Transaction.FromString(proto.signedTransactionBytes)
+    transaction_body = transaction_body_pb2.TransactionBody.FromString(transaction.bodyBytes)
+
+    assert transaction_body.tokenCreation.adminKey.ed25519 == admin_key[1]