## EPF - Week 14

Most of this week went into looking into the state db issues. Still not fully working, but hope we will get it over the finish line this coming week.

## Fixing the state db issue
Last week integration [against Erigon](https://hackmd.io/@2xic/SyCV1VDsgl#Integration-with-Erigon) started, but I was having some issues accessing the contract code part of the state. This issue is not yet fully solved, but I believe it will be solved this coming week.

So a few things happened
1. I was using a different commit when syncing my node vs what was used by the Erigon submodule for the tracer.
- We updated to the [Erigon version 3.1](https://github.com/2xic/erigon-risc-v-executable-proof-sourcing/pull/8). Unclear if this issue was part of the reason things were not working last week, but wanted to update to make sure it didn't contribute to the issue.
2. Although I could not read the code from the Erigon state reader interfaces, I verified I was able to do it over RPC.
- If the `rpcdaemon` can do it ... Then there must be some code for me to be able to replicate it. I read some of this code, I think it might be cheating by reading from the Ottersync snapshots, but it's a bit unclear. Will look more.
3. I have still not been able to read out the account code over the interface.
- Although, currently my node is at `[4/6 Execution][agg] computing trie` step which should resolve over the next few days. The aggregator `EndTxNumMinimax` returns 0 indicating it's being built and should be complete in the coming days.

In any case, if it keeps being problematic, I have a workaround. Given the interface of the `StateReader`, it should be possible to just load in the state data over RPC as a workaround. Although, I would prefer to just get things working through loading the `chaindata` from Erigon.

## Uniswap opcodes
Only opcodes missing are the `{CODE/STATIC}CALL` code from the [original list](https://hackmd.io/@2xic/HJfuLgc9ge). One complexity I somewhat forgot about this week, is how to handle nested calls. Calls clear the EVM memory, but I originally mapped the memory opcodes to RISC memory opcodes. Although given the issues with nested calls, they will also be moved to be constants which are just loaded in.

## Other things
I'm writing this update a bit late and Nethermind today published [Road to ZK Implementation: Nethermind Client’s Path to Proofs](https://www.nethermind.io/blog/road-to-zk-implementation-nethermind-clients-path-to-proofs). Seems interesting (especially the `Minimal EVM Binary` part), will explore this more this coming week. From a first look the approach looks similiar to other clients zk block proof setup.

## Next week
One of the main things that prevent us from testing against real transactions is getting a working state db. This was meant to be finished this week, but has carried over so main focus is to de-risk this.
Extended goal is to also get a Uniswap transaction proof trace working.