fix: resolve all the conflicts

Signed-off-by: Shivakumar <[email protected]>

Author: drtoxic69

examples/account/account_create_transaction_with_fallback_alias.py

@@ -1,39 +1,36 @@
-"""
-Example: Create an account where the EVM alias is derived from the main ECDSA key.
+"""Example: Create an account where the EVM alias is derived from the main ECDSA key.
 
 This demonstrates:
 - Passing only an ECDSA PrivateKey to `set_key_with_alias`
 - The alias being derived from the main key's EVM address (fallback behaviour)
 
 Usage:
-- uv run -m examples.account.account_create_transaction_with_fallback_alias
-- python -m examples.account.account_create_transaction_with_fallback_alias
-(we use -m because we use the util `info_to_dict`)
+    uv run examples/account/account_create_transaction_with_fallback_alias.py
+    python examples/account/account_create_transaction_with_fallback_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,
-    AccountInfoQuery,
-    Network,
     AccountId,
+    AccountInfo,
+    AccountInfoQuery,
+    Client,
     Hbar,
+    Network,
+    PrivateKey,
 )
 
 load_dotenv()
 network_name = os.getenv("NETWORK", "testnet").lower()
 
 
-def setup_client():
-    """Setup Client."""
+def setup_client() -> Client:
+    """Set up the Hedera client."""
     network = Network(network_name)
     print(f"Connecting to Hedera {network_name} network!")
     client = Client(network)
@@ -61,15 +58,15 @@ def generate_fallback_key() -> PrivateKey:
         sys.exit(1)
 
     print(f"✅ Account ECDSA public key: {account_public_key}")
-    print(f"✅ Derived EVM address:      {evm_address}")
+    print(f"✅ Derived EVM address:       {evm_address}")
+
     return account_private_key
 
 
-def create_account_with_fallback_alias(
-    client: Client, account_private_key: PrivateKey
-) -> AccountId:
+def create_account_with_fallback_alias(client: Client, account_private_key: PrivateKey) -> AccountId:
     """Create an account whose alias is derived from the provided ECDSA key."""
     print("\nSTEP 2: Creating the account using the fallback alias behaviour...")
+
     transaction = AccountCreateTransaction(
         initial_balance=Hbar(5),
         memo="Account with alias derived from main ECDSA key",
@@ -81,40 +78,38 @@ def create_account_with_fallback_alias(
     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."
-        )
+        raise RuntimeError("AccountID not found in receipt. 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):
+def fetch_account_info(client: Client, account_id: AccountId) -> AccountInfo:
     """Fetch account info for the given account ID."""
     print("\nSTEP 3: Fetching account information...")
+
     return AccountInfoQuery().set_account_id(account_id).execute(client)
 
 
-def print_account_summary(account_info) -> None:
+def print_account_summary(account_info: AccountInfo) -> None:
     """Print an account summary (including EVM alias)."""
     print("\nSTEP 4: Printing account EVM alias and summary...")
-    out = info_to_dict(account_info)
-    print("Account Info:")
-    print(json.dumps(out, indent=2) + "\n")
-    print(
-        "✅ contract_account_id (EVM alias on-chain): "
-        f"{account_info.contract_account_id}"
-    )
+    print("🧾 Account Info:")
+    print(account_info)
+    print("")
+    print(f"✅ contract_account_id (EVM alias on-chain): {account_info.contract_account_id}")
 
 
 def main():
-    """Main entry point."""
+    """Execute the example workflow."""
     client = setup_client()
     try:
         account_private_key = generate_fallback_key()
         new_account_id = create_account_with_fallback_alias(client, account_private_key)
         account_info = fetch_account_info(client, new_account_id)
         print_account_summary(account_info)
+
     except Exception as error:
         print(f"❌ Error: {error}")
         sys.exit(1)

examples/account/account_create_transaction_without_alias.py

@@ -1,36 +1,52 @@
-"""
-Example: Create an account without using any alias.
+"""Example: Create an account without using any alias.
 
 This demonstrates:
 - Using `set_key_without_alias` so that no EVM alias is set
 - The resulting `contract_account_id` being the zero-padded value
 
 Usage:
-- uv run python examples/account/account_create_transaction_without_alias.py
-- python examples/account/account_create_transaction_without_alias.py
+    uv run examples/account/account_create_transaction_without_alias.py
+    python examples/account/account_create_transaction_without_alias.py
 """
 
-from typing import Tuple
+import os
 import sys
+from typing import Tuple
+
+from dotenv import load_dotenv
 
 from hiero_sdk_python import (
-    Client,
-    PrivateKey,
-    PublicKey,
     AccountCreateTransaction,
-    AccountInfoQuery,
     AccountId,
     AccountInfo,
+    AccountInfoQuery,
+    Client,
     Hbar,
-    ResponseCode,
+    Network,
+    PrivateKey,
+    PublicKey,
 )
 
+load_dotenv()
+network_name = os.getenv("NETWORK", "testnet").lower()
+
+
 def setup_client() -> Client:
-    """Setup Client."""
-    client = Client.from_env()
-    print(f"Network: {client.network.network}")
-    print(f"Client set up with operator id {client.operator_account_id}")
-    return client
+    """Set up the Hedera client."""
+    network = Network(network_name)
+    print(f"Connecting to Hedera {network_name} network!")
+    client = Client(network)
+
+    try:
+        operator_id = AccountId.from_string(os.getenv("OPERATOR_ID", ""))
+        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
+    except Exception:
+        print("Error: Please check OPERATOR_ID and OPERATOR_KEY in your .env file.")
+        sys.exit(1)
+
 
 def generate_account_key() -> Tuple[PrivateKey, PublicKey]:
     """Generate a key pair for the account."""
@@ -40,10 +56,13 @@ def generate_account_key() -> Tuple[PrivateKey, PublicKey]:
     print(f"✅ Account public key (no alias): {account_public_key}")
     return account_private_key, account_public_key
 
-def create_account_without_alias(client: Client, account_public_key: PublicKey, account_private_key: PrivateKey) -> AccountId:
+
+def create_account_without_alias(
+    client: Client, account_public_key: PublicKey, account_private_key: PrivateKey
+) -> AccountId:
     """Create an account without setting any alias."""
     print("\nSTEP 2: Creating the account without setting any alias...")
-    
+
     transaction = (
         AccountCreateTransaction(
             initial_balance=Hbar(5),
@@ -55,47 +74,39 @@ def create_account_without_alias(client: Client, account_public_key: PublicKey,
     )
 
     response = transaction.execute(client)
-
-    if response.status != ResponseCode.SUCCESS:
-        raise RuntimeError(
-            f"Transaction failed with status: {response.status.name}"
-        )
-
     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."
-        )
+        raise RuntimeError("AccountID not found in receipt. 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:
     """Fetch account information."""
-    account_info = (
-        AccountInfoQuery()
-        .set_account_id(account_id)
-        .execute(client)
-    )
-    return account_info
+    print("\nSTEP 3: Fetching account information...")
+    return AccountInfoQuery().set_account_id(account_id).execute(client)
+
 
 def main() -> None:
-    """Main entry point."""
+    """Execute the example workflow."""
     try:
         client = setup_client()
         account_private_key, account_public_key = generate_account_key()
+
         new_account_id = create_account_without_alias(client, account_public_key, account_private_key)
+
         account_info = fetch_account_info(client, new_account_id)
-        print("\nAccount Info:")
+
+        print("\n🧾 Account Info:")
         print(account_info)
-        print(
-            "\n✅ contract_account_id (no alias, zero-padded): "
-            f"{account_info.contract_account_id}"
-        )
+        print(f"\n✅ contract_account_id (no alias, zero-padded): {account_info.contract_account_id}")
+
     except Exception as error:
         print(f"❌ Error: {error}")
         sys.exit(1)
 
+
 if __name__ == "__main__":
     main()