fix: change BlocksByRoot container de/serialization

[MegaRedHand]

The request type was changed in leanEthereum/leanSpec@054b2e9. This PR updates it to the latest format.

[github-actions]

Kimi AI Code Review

### Review

Code Correctness and Potential Bugs

1. Lines 99-100: The change from request.len() to request.roots.len() is correct, as the request now contains a roots field which is a RequestedBlockRoots type. This ensures the correct number of roots in the request is retrieved.

2. Lines 166-167: The change from BlocksByRootRequest to RequestedBlockRoots is correct, as the new structure of BlocksByRootRequest now includes a roots field. This change is consistent with the updated structure.

3. Lines 46-49: The addition of RequestedBlockRoots and the BlocksByRootRequest struct is correct. It encapsulates the roots in a struct, which is a good practice for clarity and maintainability.

Security Vulnerabilities

The changes do not introduce any new security vulnerabilities. However, it's important to ensure that the de/serialization process is secure and does not introduce any vulnerabilities, such as deserialization of untrusted data leading to unexpected behavior.

Performance Implications

The changes are structural and do not directly impact performance. However, it's important to monitor the performance after these changes, especially if the new structure leads to additional overhead in de/serialization.

Rust Best Practices and Idiomatic Patterns

1. Lines 166-167: The use of RequestedBlockRoots::empty() is idiomatic Rust, as it leverages the empty method provided by the ssz_types::VariableList to create an empty list.

2. Lines 46-49: The struct BlocksByRootRequest follows Rust's best practices by encapsulating the roots field, making the API more explicit and easier to understand.

Memory Safety and Proper Error Handling

1. Lines 166-167: The error handling for pushing a root into the roots list is appropriate. It logs an error and returns false if the operation fails, which is a reasonable approach to handle such errors.

Code Readability and Maintainability

1. Lines 46-49: The new BlocksByRootRequest struct improves readability by clearly separating the roots field, making the code easier to understand and maintain.

2. Lines 99-100 and 166-167: The changes make the code more readable by using more descriptive field names and structuring the data in a more intuitive way.

Consensus-Layer Considerations

The changes do not directly affect consensus-layer logic such as fork choice, attestation processing, or state transition functions. However, it's important to ensure that these changes do not inadvertently affect the serialization and deserialization of consensus-related data.

Conclusion

The changes in this PR are well-structured and follow Rust best practices. They improve code readability and maintainability without introducing new security vulnerabilities or performance issues. The changes are correct and should be merged. However, it's crucial to thoroughly test the updated serialization and deserialization logic to ensure there are no regressions or unintended consequences.

---

Automated review by Kimi (Moonshot AI)