refactor: use native AccountInfo string representation in examples

Signed-off-by: Shivakumar <shivakumarjagadish12@gmail.com>

Author: drtoxic69

CHANGELOG.md

@@ -109,6 +109,7 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 - Added comprehensive unit tests for Timestamp class (#1158)
 - Enhance unit and integration test review instructions for clarity and coverage `.coderabbit.yaml`.
 - Issue reminder bot now explicitly mentions assignees (e.g., `@user`) in comments. ([#1232](https://github.com/hiero-ledger/hiero-sdk-python/issues/1232))
+- Refactored `examples/account/account_create_transaction_create_with_alias.py` and `examples/account/account_create_transaction_evm_alias.py` to use the native `AccountInfo.__str__` method for printing account details, replacing manual JSON serialization. ([#1263](https://github.com/hiero-ledger/hiero-sdk-python/issues/1263))
 
 ### Fixed
 
@@ -124,6 +125,10 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 - Fixed `cron-check-broken-links.yml` string parsing issue in context input `dry_run` (#1235)
 - Flaky tests by disabling TLS in mock Hedera nodes in `mock_server.py`
 
+### Removed
+
+- Deleted `examples/utils.py` as its helper functions are no longer needed. ([#1263](https://github.com/hiero-ledger/hiero-sdk-python/issues/1263))
+
 ### Breaking Change
 
 - Remove deprecated 'in_tinybars' parameter and update related tests `/src/hiero_sdk_python/hbar.py`, `/tests/unit/hbar_test.py` and `/src/hiero_sdk_python/tokens/custom_fixed_fee.py`.

examples/account/account_create_transaction_create_with_alias.py

@@ -1,41 +1,36 @@
-"""
-Example: Create an account using a separate ECDSA key for the EVM alias.
-
-This demonstrates:
-- Using a "main" key for the account
-- Using a separate ECDSA public key as the EVM alias
-- The need to sign the transaction with the alias private key
+"""Example of creating an account using a separate ECDSA key for the EVM alias.
 
 Usage:
-- uv run -m examples.account.account_create_transaction_create_with_alias
-- python -m examples.account.account_create_transaction_create_with_alias
-(we use -m because we use the util `info_to_dict`)
+    uv run examples/account/account_create_transaction_create_with_alias.py
+    python examples/account/account_create_transaction_create_with_alias.py
 """
 
 import os
 import sys
-import json
-from dotenv import load_dotenv
 
-from examples.utils import info_to_dict
+from dotenv import load_dotenv
 
 from hiero_sdk_python import (
-    Client,
-    PrivateKey,
     AccountCreateTransaction,
-    AccountInfo,
-    AccountInfoQuery,
-    Network,
     AccountId,
+    AccountInfoQuery,
+    Client,
     Hbar,
+    Network,
+    PrivateKey,
 )
 
 load_dotenv()
 network_name = os.getenv("NETWORK", "testnet").lower()
 
 
 def setup_client():
-    """Setup Client."""
+    """Initialize client and return operator credentials.
+
+    Returns:
+        tuple: A tuple containing (Client, operator_id, operator_key).
+
+    """
     network = Network(network_name)
     print(f"Connecting to Hedera {network_name} network!")
     client = Client(network)
@@ -45,25 +40,25 @@ def setup_client():
         operator_key = PrivateKey.from_string(os.getenv("OPERATOR_KEY", ""))
         client.set_operator(operator_id, operator_key)
         print(f"Client set up with operator id {client.operator_account_id}")
-        return client
+        return client, operator_id, operator_key
+
     except Exception:
         print("Error: Please check OPERATOR_ID and OPERATOR_KEY in your .env file.")
         sys.exit(1)
 
 
-def generate_main_and_alias_keys() -> tuple[PrivateKey, PrivateKey]:
+def generate_main_and_alias_keys():
     """Generate the main account key and a separate ECDSA alias key.
 
     Returns:
         tuple: (main_private_key, alias_private_key)
+
     """
     print("\nSTEP 1: Generating main account key and separate ECDSA alias key...")
 
-    # Main account key (can be any key type, here ed25519)
     main_private_key = PrivateKey.generate()
     main_public_key = main_private_key.public_key()
 
-    # Separate ECDSA key used only for the EVM alias
     alias_private_key = PrivateKey.generate("ecdsa")
     alias_public_key = alias_private_key.public_key()
     alias_evm_address = alias_public_key.to_evm_address()
@@ -79,100 +74,90 @@ def generate_main_and_alias_keys() -> tuple[PrivateKey, PrivateKey]:
     return main_private_key, alias_private_key
 
 
-def create_account_with_ecdsa_alias(
-    client: Client, main_private_key: PrivateKey, alias_private_key: PrivateKey
-) -> AccountId:
+def create_account_with_ecdsa_alias(client, main_private_key, alias_private_key, operator_key):
     """Create an account with a separate ECDSA key as the EVM alias.
 
     Args:
-        client: The Hedera client.
-        main_private_key: The main account private key.
-        alias_private_key: The ECDSA private key for the EVM alias.
+        client: The initialized Client instance.
+        main_private_key: The private key for the main account.
+        alias_private_key: The private key for the alias (needed for signing).
+        operator_key: The operator's private key (payer).
 
     Returns:
-        AccountId: The newly created account ID.
+        AccountId: The ID of the newly created account.
+
     """
     print("\nSTEP 2: Creating the account with the EVM alias from the ECDSA key...")
 
     alias_public_key = alias_private_key.public_key()
 
-    # Use the helper that accepts both the main key and the ECDSA alias key
-    transaction = (
-        AccountCreateTransaction(
-            initial_balance=Hbar(5),
-            memo="Account with separate ECDSA alias",
-        )
-        .set_key_with_alias(main_private_key, alias_public_key)
-    )
-
-    # Freeze and sign:
-    # - operator key signs as payer (via client)
-    # - alias private key MUST sign to authorize the alias
-    transaction = (
-        transaction.freeze_with(client)
-        .sign(alias_private_key)
-    )
+    transaction = AccountCreateTransaction(
+        initial_balance=Hbar(5),
+        memo="Account with separate ECDSA alias",
+    ).set_key_with_alias(main_private_key, alias_public_key)
+
+    # Freeze and sign with BOTH keys
+    transaction = transaction.freeze_with(client).sign(alias_private_key).sign(operator_key)
 
     response = transaction.execute(client)
-    new_account_id = response.account_id
 
+    # Safe retrieval of account ID
+    new_account_id = response.account_id
     if new_account_id is None:
-        raise RuntimeError(
-            "AccountID not found in receipt. Account may not have been created."
-        )
+        try:
+            new_account_id = response.get_receipt(client).account_id
+        except Exception:
+            raise RuntimeError("AccountID not found. Account may not have been created.")
 
     print(f"✅ Account created with ID: {new_account_id}\n")
     return new_account_id
 
 
-def fetch_account_info(client: Client, account_id: AccountId) -> AccountInfo:
+def fetch_account_info(client, account_id):
     """Fetch account information from the network.
 
     Args:
-        client: The Hedera client.
-        account_id: The account ID to query.
+        client: The initialized Client instance.
+        account_id: The ID of the account to query.
 
     Returns:
-        AccountInfo: The account info object.
+        AccountInfo: The account information object.
+
     """
     print("\nSTEP 3: Fetching account information...")
-    account_info = (
-        AccountInfoQuery()
-        .set_account_id(account_id)
-        .execute(client)
-    )
-    return account_info
+    return AccountInfoQuery().set_account_id(account_id).execute(client)
 
 
-def print_account_summary(account_info: AccountInfo) -> None:
+def print_account_summary(account_info):
     """Print a summary of the account information.
 
     Args:
-        account_info: The account info object to display.
+        account_info: The AccountInfo object to display.
+
     """
-    out = info_to_dict(account_info)
-    print("Account Info:")
-    print(json.dumps(out, indent=2) + "\n")
+    print("--- Account Info ---")
+    print(account_info)
+    print("--------------------\n")
 
     if account_info.contract_account_id is not None:
-        print(
-            f"✅ Contract Account ID (EVM alias on-chain): "
-            f"{account_info.contract_account_id}"
-        )
+        print(f"✅ Contract Account ID (EVM alias on-chain): {account_info.contract_account_id}")
     else:
         print("❌ Error: Contract Account ID (alias) does not exist.")
 
 
 def main():
-    """Main entry point."""
+    """Run the example workflow."""
     try:
-        client = setup_client()
+        client, _, operator_key = setup_client()
+
         main_private_key, alias_private_key = generate_main_and_alias_keys()
-        account_id = create_account_with_ecdsa_alias(
-            client, main_private_key, alias_private_key
-        )
+
+        account_id = create_account_with_ecdsa_alias(client, main_private_key, alias_private_key, operator_key)
+
         account_info = fetch_account_info(client, account_id)
+
         print_account_summary(account_info)
+
     except Exception as error:
         print(f"❌ Error: {error}")
         sys.exit(1)