fix: align struct fields for smallest memory use

[wolf31o2]

Summary by CodeRabbit

• Refactor
  • Internal struct field reordering for improved code organization and consistency.
  • Removed duplicate field entry in configuration structures.

[coderabbitai]

Walkthrough

The PR reorganizes struct field orders across three configuration and API response files. Changes include reordering fields in requestChainSyncSync, responseLocalStateQueryCurrentEra, responseLocalStateQueryTip, LoggingConfig, and NodeConfig, plus removing a duplicate SocketPath field. No logic or behavior modifications.

Changes

Cohort / File(s)	Summary
API Request/Response Field Reordering internal/api/chainsync.go, internal/api/localstatequery.go	Reordered struct fields: Slot moved after Hash in requestChainSyncSync; Id moved after Name in responseLocalStateQueryCurrentEra; Hash moved after Era in responseLocalStateQueryTip
Configuration Field Reordering & Deduplication internal/config/config.go	Reordered LoggingConfig.Healthchecks after Level; moved NodeConfig.NetworkMagic after Timeout; removed duplicate NodeConfig.SocketPath field

Estimated code review effort

🎯 1 (Trivial) | ⏱️ ~3 minutes

Pre-merge checks and finishing touches

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%.	You can run @coderabbitai generate docstrings to improve docstring coverage.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title Check	✅ Passed	The PR title "fix: align struct fields for smallest memory use" accurately describes the main objective of the changeset. The pull request reorders struct fields across three files (chainsync.go, localstatequery.go, and config.go), which is a technique used in Go to optimize memory layout and reduce padding. The title is concise, specific, and clearly conveys to a reviewer that this PR focuses on memory optimization through struct field alignment. The changes are entirely consistent with the stated purpose.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch fix/fieldalignment

---

📜 Recent review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 135e2a0 and 58fbc6b.

📒 Files selected for processing (3)

• internal/api/chainsync.go (1 hunks)
• internal/api/localstatequery.go (2 hunks)
• internal/config/config.go (2 hunks)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Analyze (go)

🔇 Additional comments (5)

internal/api/chainsync.go (1)

38-42: Field reordering follows best practice for alignment.

The reordering (string → uint64 → bool) follows Go best practices by ordering fields in descending size. However, both the original and new layouts result in 32 bytes due to padding requirements. While this doesn't reduce memory footprint, it does improve code maintainability by following standard struct layout conventions.

internal/api/localstatequery.go (2)

38-41: Field reordering follows best practice for alignment.

Reordering to place the larger field (string, 16 bytes) before the smaller field (uint8, 1 byte) follows standard Go struct layout conventions. Both layouts result in 24 bytes, so there's no memory reduction, but the change improves consistency with alignment best practices. The JSON tag ensures the API contract remains unchanged.

---

150-156: Field grouping is logical; no memory impact.

Moving Hash to immediately follow Era groups the two string fields together. Since all fields are either strings (16 bytes) or 8-byte integers, both the original and new layouts result in 56 bytes with natural alignment. The reordering doesn't reduce memory but may improve code readability. The JSON tags preserve the API contract.

internal/config/config.go (2)

36-39: Field reordering follows best practice for alignment.

Placing the larger field (string, 16 bytes) before the smaller field (bool, 1 byte) aligns with Go struct layout best practices. Both layouts result in 24 bytes, so there's no memory reduction, but the change maintains consistency with standard conventions.

---

56-65: Excellent memory optimization achieved!

This reordering achieves meaningful memory savings by moving NetworkMagic (uint32, 4 bytes) from before Address to after Timeout. The original placement would have required 4 bytes of padding after NetworkMagic to align the subsequent string field, resulting in 88 bytes total. The new layout groups all strings together, followed by larger integers, then smaller integers, reducing the struct size to 80 bytes—an 8-byte (10%) reduction. This is a textbook example of effective struct field alignment optimization.

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}