# Week 18 Update: Odinson

After last week, as mentioned in the week 17 update, I wrote some tests on the work I have done, made sure the memory measurement, recompute, pruning, all of it is working fine and as intended.

I have lately been revising some of the consensus related concepts that I might have taken a glance at but was unable to deep dive previously during the study group. Looked into topics like relays, builders, MEV, how it all works and is tied to block processing, bidding etc. Apart from that, I was also going through the EVM by watching this [lecture](https://www.youtube.com/watch?v=gYnx_YQS8cM).

Finally, been giving some time to working on Rust as well. Came across [these](https://cliffle.com/p/dangerust/) series of articles, and have been looking into this. Apart from that, attended the [ACDC#167](https://www.youtube.com/watch?v=XBvBEHPqGhM)

The [ACDC#167](https://www.youtube.com/watch?v=XBvBEHPqGhM) call mainly focused on Fusaka's progress and Glamsterdam planning. Fusaka Devnet 3 continues running smoothly with only minor bugs that have been resolved, and both Holesky and Sepolia forks executed successfully.

A significant discussion centered around bandwidth optimization for blob retrieval, where developers explored solutions like "light supernode" mode, EL side tracking for rollup specific blobs, and storage trade-offs to cut custody costs by nearly 50%. This is particularly important for decentralized sequencers that struggle with high bandwidth requirements.

For Glamsterdam, the major debate was about Trustless Payments and ePBS integration.

## Work for the week

This week I focused on adding tests to validate the memory measurement, byte limit enforcement, and recompute behavior of the state cache implementation. The tests cover several scenarios to make sure the current implementation works as intended.

Added tests to verify the memory measurement accuracy - these check that the `measure_cached_memory_size` function correctly calculates the total memory footprint of cached states, including handling of shared `Arc` references through the `MemoryTracker`. Made sure to test edge cases like empty caches and caches with multiple states.

Also implemented tests for the byte limit enforcement mechanism. These validate that when the cache exceeds the configured `max_cached_bytes` limit, the pruning logic correctly removes states in batches until we're back under the threshold. The tests also verify that the batch size is properly clamped between 5 and 64 based on the headroom value.

Apart from that, added tests for the recompute behavior, specifically checking that the `recompute_cached_bytes` function is triggered at the right intervals (after every `RECOMPUTE_INTERVAL` inserts) and that the `needs_remeasure` flag works correctly. These tests ensure that we're not unnecessarily recomputing memory size on every insert, which would be expensive.

All of these tests are available in this [commit](https://github.com/sigp/lighthouse/pull/7803/commits/7ff72d5f0db7fed52f78d96a168bf41bb039d05b) in my project PR.

## Resources

1. Project [PR](https://github.com/sigp/lighthouse/pull/7803)
2. [ACDC #167](https://www.youtube.com/watch?v=XBvBEHPqGhM)
3. [Learn Rust the Dangerous Way](https://cliffle.com/p/dangerust/)

## Conclusion

A decent week, focusing more on looking into the consensus side and upskilling in Rust, as I await further updates and reviews. Been putting some time into the ACDC/E calls to know about the current state of work and what the core devs have been upto