Nethermind as rbuilder state provider

[mralj]

Goal

Nethermind client should work as a state provider for rbuilder.
Firstly, the state will be provided via IPC RPC, and then we'll optimize (e.g., Rust <> C# FFI).

TODOs

• Implement necessary SatateProviderFactory traits
• Implement necessary StateProvider traits
• Implement HeaderProvider traits
• Implement state root calculation (dependent on the Flashbots team to refactor the traits)
• Test using Backtest Builders
• Test using Live builder

Here is the list of the Traits we'll have to implement:

Column Already supported by NM? indicates that the:

1. RPC call already exists in the NM client
2. NM client supports both arg and return types (they are either "the same" or there is a small amount of work to be done to support the requirements fully)

If the args or return data needs to be adapted from/to NM-specific types, I propose adapters to be implemented on the rbuilder side where possible since this is specific to rbuilder and not the NM client.

StateProviderFactory

Trait	Done?	Already supported by NM?
latest	✅	✅
history_by_block_hash	✅	✅
last_block_number	✅	✅

StateProvider

Trait	Done?	Already supported by NM?
storage	✅	✅
bytecode_by_hash	✅	✅
block_hash	✅	✅
basic_account	✅	✅

HeaderProvider

Trait	Done?	Already supported by NM?
header	✅	✅

[mralj]

@asdacap, can you please look into the following (by look into, I mean either let me know RPC methods if they already exist or implement new ones)

1. bytecode_by_hash

I'm not sure what the RPC call is for this one (or if NM supports it), here is how I implemented it (following Ferran's PR), but I don't think this is the correct implementation:

fn bytecode_by_hash(&self, code_hash: B256) -> ProviderResult<Option<Bytecode>> {
        let address = Address::from_word(code_hash);
        let block_id = BlockId::hash(self.hash);

        let res = futures::executor::block_on(async {
            self.provider.get_code_at(address).block_id(block_id).await
        })
        .unwrap();

        Ok(Some(Bytecode::new_raw(res)))
    }

This doesn't look correct because the get_code_at RPC call expects Address, and the bytecode_by_hash trait provides code_hash (the hash of the code we are fetching).
So my questions are:

1. Is this code indeed incorrect? If it is incorrect,
2. Does NM already support this call out of the box, and if not, can it be implemented on the NM side?

2. calculate_state_root

We'll need an RPC call to calculate the state root (if one doesn't already exist) on the NM side. The rbuilder provides:

1. parent_hash (so we can get the previous state_root by reading the parent block via the provided hash)
2. ExecutionOutcome which has BundleState containing the state diff (from BundleState struct I think we only need the state and the contracts.

If I'm not mistaken, this should be enough to calculate state_root. I
If NM doesn't already have an RPC call which supports this, can you implement one and let me know the API spec?

[asdacap]

So for 1, I think it probably mean that you'll need to get the account for the address first, which contains the codehash.
For 2, its not available. I'll think of an API spec.

[mralj]

So for 1, I think it probably mean that you'll need to get the account for the address first, which contains the codehash.

Yeah, but the issue is that the bytecode_by_hash trait doesn't have (access to) the address, it only receives the code_hash.
I'd have to somehow find the account by code_hash, is this already possible in NM via RPC? If not we'll have to add support for this as well.

[asdacap]

Ow, thats fine. I thought it only pass in Address as some kind of optimization. We can get code by hash directly.