Override `freeze_with()` in TopicCreateTransaction to apply default `autoRenewAccountId` behavior

[manishdait]

🧑‍🔬 Advanced Issue

Welcome! This is an Advanced Issue touching core SDK architecture.

It is designed for expert contributors who have demonstrated deep architectural understanding and a proven track record of high-quality contributions.

🐞 Problem Description

The current implementation of TopicCreateTransaction does not apply the documented default behavior for autoRenewAccountId.

According to the Hedera documentation:

"If the developer does not explicitly set autoRenewAccount, the SDK will automatically default to using the transaction fee payer account ID for the auto renew account. This is beneficial in the event an admin key is not set."

Reference:
https://docs.hedera.com/hedera/sdks-and-apis/sdks/consensus-service/create-a-topic

Currently, when autoRenewAccountId is not explicitly set, the transaction freezes with auto_renew_account left as None.

This creates a mismatch between the SDK behavior and the documented expectations, and may lead to topic creation behavior that differs from other SDK implementations.

🛠️ Implementation Notes

• Override freeze_with() in TopicCreateTransaction to
  • Check whether autoRenewAccount is already set. If not set, verify that:
    • a valid client is provided
    • the client has an operator_account_id
  • Set autoRenewAccount using:
    • transaction_id.account_id if a transaction_id is present
    • otherwise client.operator_account_id
  • Preserve the existing value when autoRenewAccount was explicitly provided by the user.

if client is not None and client.operator_account_id is not None and self.auto_renew_account is  None:
     self.auto_renew_account = (
         self.transaction_id.account_id if self.transaction_id is not None else client.operator_account_id
     )

• Add the unit test to verify this behavior
• Update the TCK for create topic transaction to utilize this

🧠 Advanced Contributors — Prerequisites & Expectations

Caution

Advanced issues are the highest-risk work in this project. We will reject PRs that do not meet these standards.

🏁 Concrete Prerequisites

• Advanced Language: Proficient with Python.
• Expertise: Deep architectural understanding of _Executable, Transaction, and Query base classes.
• Proven History: Successfully completed ≥ 10 intermediate issues in this repo.
• Consistency: ≥ 3–4 months of active, human-led contributions to this SDK.

Note

CI/CD Exception: For issues focused on GitHub Actions / Workflows, the repo-specific thresholds above may be waived if the contributor demonstrates advanced-level proficiency in CI/CD.

⚠️ AI Usage Policy

• Using AI to generate code for Advanced issues is strictly discouraged
• AI may be used to help explain file relationships, but cannot be the main source of research.
• Submitting AI-generated or unvalidated code is grounds for immediate closure

⏱️ Timeline & Workflow

• Typical time: ~1 month / ~50 hours.
• 🔴 Completing an advanced issue in 1–3 days is a red flag and will likely be rejected.
• Suggested: Post your proposed architectural approach as a comment and wait for explicit maintainer approval before writing any code.

🔬 Technical Domains

• API Client Architecture (request → serialization → execution → response mapping)
• Backward Compatibility (preserving method signatures, defaults, and return types)
• Protobuf Alignment (reading .proto files, _to_proto() / _from_proto() correctness)
• State & Immutability (correct usage of guards like _require_not_frozen)
• Execution Boundaries (retry logic, backoff, node selection, gRPC deadlines)
• Testing (unit, integration, mocking, test coverage for edge cases and failure modes)

🛡️ Quality & Review Standards

Advanced PRs must be "safe, maintainable, architecturally sound, and production-ready."

1. Architectural Fit: The solution must fit naturally into the existing SDK abstractions.
2. Security & Correctness: Evaluate all logic for injection risks, state corruption, or thread-safety issues.
3. Maintainability: Code must be short and clear enough for any other maintainer to debug without your assistance.
4. Backward Compatibility: Public API signatures must be preserved. If a breaking change is required, it must be explicitly managed through a deprecation cycle.
5. Comprehensive Testing: Must include unit and integration tests covering all new logic paths, edge cases, and failure modes. AI generated tests based on AI generated code is grounds for immediate rejection.

✅ PR Quality Checklist

Before opening your PR, the contributor must confirm:

• I have spent the majority of my time researching the problem and solution space extensively, including reviewing relevant code, documentation, and external resources.
• I understand the system-wide impact of these changes on affected modules and performance.
• The system design fits with current Hiero SDK architectural approaches.
• I have tested my changes extensively against both local and network environments.
• I have verified naming, types, and field ordering against pinned Protobufs.
• Every line of code is personally understood and explainable.

📚 Resources & Support

References:

• Hedera Protobufs

Python SDK References:

• SDK Project Structure
• Transaction Lifecycle
• Executable Architecture
• Hedera Protobufs (services)
• Browse closed advanced PRs — see how others did it

🆘 Stuck?

• Community Calls
• Discord

[github-actions]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Override freeze_with() in TopicCreateTransaction following the established TokenCreateTransaction pattern
• Apply defensive checks to only set defaults when auto_renew_account is None and valid client context exists
• Move the default assignment logic from the TCK handler into the transaction class for consistent behavior across all SDK usage paths
• Add comprehensive unit tests covering all edge cases for the new freeze behavior

Design Choices

Design Choice 1: Ticket code snippet contains a logic error

Options Considered:

1. Follow the ticket's code snippet literally (set auto_renew_account only when it's already set - makes no sense)
2. Follow the ticket's textual description and existing TokenCreateTransaction pattern (set auto_renew_account only when it's None)

Chosen Option: 2

Rationale: The textual requirements clearly state to "preserve the existing value when autoRenewAccount was explicitly provided," and the TokenCreateTransaction.freeze_with() pattern confirms this is the intended behavior.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Override freeze_with() in TopicCreateTransaction

This phase implements the core functionality by adding a freeze_with() override to TopicCreateTransaction that applies the documented default behavior for auto_renew_account.

Add freeze_with() Override

Add the freeze_with() method override to TopicCreateTransaction that auto-assigns auto_renew_account when not explicitly set by the user.

• Add freeze_with(self, client) -> TopicCreateTransaction method to src/hiero_sdk_python/consensus/topic_create_transaction.py
• Check if auto_renew_account is None before applying any default
• When auto_renew_account is None and client is valid with an operator_account_id:
  • Use self.transaction_id.account_id if transaction_id is already set
  • Otherwise fall back to client.operator_account_id
• Call super().freeze_with(client) to delegate to base class implementation
• Follow the existing TokenCreateTransaction.freeze_with() pattern in src/hiero_sdk_python/tokens/token_create_transaction.py as reference
• Add appropriate docstring explaining the auto-assignment behavior

🤖 Prompt for AI agents

Implement the core `freeze_with()` override in `TopicCreateTransaction` so that
`auto_renew_account` is automatically defaulted to the fee payer's account ID
when not explicitly provided.

- In `src/hiero_sdk_python/consensus/topic_create_transaction.py`, add a
`freeze_with(self, client) -> TopicCreateTransaction` method
- At the start of the method, check if `self.auto_renew_account` is `None`:
  - If `None` and client is valid and has a non-`None` `operator_account_id`:
- Set `self.auto_renew_account` to `self.transaction_id.account_id` if
`self.transaction_id` is already set
    - Otherwise, set `self.auto_renew_account` to `client.operator_account_id`
  - If not `None`, leave the existing value untouched
- After applying the default, call `super().freeze_with(client)` to delegate to
the base class
- Add a docstring explaining the auto-assignment behavior
- Use `src/hiero_sdk_python/tokens/token_create_transaction.py`'s
`freeze_with()` as the reference pattern

Phase 2: Testing and TCK Integration

This phase adds comprehensive unit tests for the new behavior and updates the TCK handler to utilize the transaction's built-in default assignment.

Task 1: Add Unit Tests for freeze_with() Behavior

Add unit tests to verify the freeze_with() override correctly handles all scenarios for auto_renew_account assignment.

• Add tests to tests/unit/topic_create_transaction_test.py
• Test case: auto_renew_account defaults to client.operator_account_id when not set and no transaction_id
• Test case: auto_renew_account defaults to transaction_id.account_id when transaction_id is preset
• Test case: Explicitly set auto_renew_account is preserved (not overwritten)
• Test case: Verify behavior when client is None (should not raise, just skip defaulting)
• Test case: Verify behavior when client.operator_account_id is None
• Use existing test fixtures and patterns from the test file for consistency

Task 2: Update TCK Handler

Update the TCK handler for topic creation to rely on the transaction's freeze_with() for default auto_renew_account assignment instead of applying it manually.

• Modify tck/handlers/topic.py in the create_topic() function
• Remove or simplify the manual auto_renew_account assignment logic (currently around lines 76-78)
• The transaction's freeze_with() will now handle this when apply_common_params() triggers freezing
• Ensure the TCK still works correctly by verifying that auto_renew_account gets set appropriately through the transaction mechanism
• Verify no functional change occurs from the TCK's perspective (same behavior, cleaner implementation)

🤖 Prompt for AI agents

Add unit tests for all `freeze_with()` scenarios in `TopicCreateTransaction` and
clean up the TCK handler to remove now-redundant manual defaulting logic.

**Unit Tests** — add to `tests/unit/topic_create_transaction_test.py`:
- Follow existing test fixtures and patterns already present in the file
- Cover all of the following cases:
1. `auto_renew_account` defaults to `client.operator_account_id` when not set
and no `transaction_id` is present
2. `auto_renew_account` defaults to `transaction_id.account_id` when
`transaction_id` is preset on the transaction
3. An explicitly set `auto_renew_account` is preserved and not overwritten by
`freeze_with()`
  4. No exception is raised when client is `None`; defaulting is simply skipped
5. No exception is raised when `client.operator_account_id` is `None`;
defaulting is simply skipped

**TCK Handler** — modify `tck/handlers/topic.py`:
- In the `create_topic()` function, remove or simplify the manual
`auto_renew_account` assignment logic (currently around lines 76-78)
- The transaction's `freeze_with()` (called via `apply_common_params()`) now
owns this defaulting responsibility
- Ensure no functional behavior change from the TCK's perspective after the
cleanup

Research

The project is a Python SDK for the Hiero/Hedera network. TopicCreateTransaction extends the base Transaction class and is located in src/hiero_sdk_python/consensus/topic_create_transaction.py. The transaction has an optional auto_renew_account field that currently remains None when not explicitly set. The base Transaction.freeze_with() method in src/hiero_sdk_python/transaction/transaction.py handles freezing logic but doesn't apply transaction-specific defaults. A similar pattern exists in TokenCreateTransaction which overrides freeze_with() to auto-assign auto_renew_account_id. The TCK handler in tck/handlers/topic.py currently contains redundant logic to set auto_renew_account from the client operator, which should be moved into the transaction class itself.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the core `freeze_with()` override in `TopicCreateTransaction` so that
`auto_renew_account` is automatically defaulted to the fee payer's account ID
when not explicitly provided.

- In `src/hiero_sdk_python/consensus/topic_create_transaction.py`, add a
`freeze_with(self, client) -> TopicCreateTransaction` method
- At the start of the method, check if `self.auto_renew_account` is `None`:
  - If `None` and client is valid and has a non-`None` `operator_account_id`:
- Set `self.auto_renew_account` to `self.transaction_id.account_id` if
`self.transaction_id` is already set
    - Otherwise, set `self.auto_renew_account` to `client.operator_account_id`
  - If not `None`, leave the existing value untouched
- After applying the default, call `super().freeze_with(client)` to delegate to
the base class
- Add a docstring explaining the auto-assignment behavior
- Use `src/hiero_sdk_python/tokens/token_create_transaction.py`'s
`freeze_with()` as the reference pattern
===============================================================================

Task: 2

Add unit tests for all `freeze_with()` scenarios in `TopicCreateTransaction` and
clean up the TCK handler to remove now-redundant manual defaulting logic.

**Unit Tests** — add to `tests/unit/topic_create_transaction_test.py`:
- Follow existing test fixtures and patterns already present in the file
- Cover all of the following cases:
1. `auto_renew_account` defaults to `client.operator_account_id` when not set
and no `transaction_id` is present
2. `auto_renew_account` defaults to `transaction_id.account_id` when
`transaction_id` is preset on the transaction
3. An explicitly set `auto_renew_account` is preserved and not overwritten by
`freeze_with()`
  4. No exception is raised when client is `None`; defaulting is simply skipped
5. No exception is raised when `client.operator_account_id` is `None`;
defaulting is simply skipped

**TCK Handler** — modify `tck/handlers/topic.py`:
- In the `create_topic()` function, remove or simplify the manual
`auto_renew_account` assignment logic (currently around lines 76-78)
- The transaction's `freeze_with()` (called via `apply_common_params()`) now
owns this defaulting responsibility
- Ensure no functional behavior change from the TCK's perspective after the
cleanup

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[danielmarv]

/assign