Calling a smart contract from within the PayloadBuilder context

[squadgazzz]

I am trying to implement a custom payload builder that should call a smart contract when a new payload is being built. Currently, I am using alloy-sol-macro to generate Rust binding for the smart contract. It requires transport in order to communicate with the SC(alloy_provider::Provider).

Here is a simplified version of the payload builder. Where I have access to the Reth's FullNodeTypes::Provider only. Also comments in the snipped explain the main issue.

impl<Node, Pool> PayloadBuilderBuilder<Node, Pool> for CustomOpPayloadBuilder
where
    Node: FullNodeTypes<
        Types: NodeTypesWithEngine<
            Engine = OpEngineTypes,
            ChainSpec = OpChainSpec,
            Primitives = OpPrimitives,
        >,
    >,
    Pool: TransactionPool<Transaction: PoolTransaction<Consensus = TxTy<Node::Types>>>
        + Unpin
        + 'static,
{
    type PayloadBuilder = OpPayloadBuilder<Pool, Node::Provider>;

    async fn build_payload_builder(
        self,
        ctx: &BuilderContext<Node>,
        pool: Pool,
    ) -> eyre::Result<Self::PayloadBuilder> {
        // This is the reth's provider: FullNodeTypes::Provider
        let provider = ctx.provider().clone();
        // At this point an alloy_provider::Provider needs to be constructed here somehow
        let sc_instance = IMySmartContractInstance::new(self.entry_point_address, provider);
        Ok(OpPayloadBuilder::new(
            OpEvmConfig::optimism(ctx.chain_spec()),
            pool,
            ctx.provider().clone(),
            self.flashblocks_ws_url.clone(),
            self.chain_block_time,
            self.flashblock_block_time,
            sc_instance,
        ))
    }
}

In the build_payload_builder function of the payload builder, I have access only to a ctx: &BuilderContext<Node>. This context provides a FullNodeTypes::Provider that is used to communicate with the node’s state. However, this provider doesn’t expose the transport functionality needed to call smart contracts.

To address the transport issue, I attempted to create an adapter that wraps the reth provider to implement alloy_provider::Provider. A simplified version of my adapter looks like this:

use alloy_network::AnyNetwork;
use alloy_primitives::{Address, U64};
use alloy_provider::{Provider, ProviderCall, ProviderLayer, RootProvider, RpcWithBlock};
use alloy_rpc_client::NoParams;
use alloy_transport::TransportErrorKind;
use reth::builder::node::FullNodeTypes;
use reth_node_types::NodeTypesWithEngine;
use reth_optimism_chainspec::OpChainSpec;
use reth_optimism_node::OpEngineTypes;
use reth_optimism_primitives::OpPrimitives;
use reth_provider::{BlockNumReader, StateProviderFactory};
use reth_revm::database::EvmStateProvider;

#[derive(Clone, Debug)]
pub struct RethDbLayer<Node: FullNodeTypes>(pub Node::Provider);

impl<P, Node> ProviderLayer<P, AnyNetwork> for RethDbLayer<Node>
where
    P: Provider<AnyNetwork> + Clone,
    Node: FullNodeTypes<
        Types: NodeTypesWithEngine<
            Engine = OpEngineTypes,
            ChainSpec = OpChainSpec,
            Primitives = OpPrimitives,
        >,
    >,
{
    type Provider = RethDbProvider<P, Node>;

    fn layer(&self, inner: P) -> Self::Provider {
        RethDbProvider::new(inner, self.0.clone())
    }
}

#[derive(Clone, Debug)]
pub struct RethDbProvider<P, Node: FullNodeTypes> {
    inner: P,
    reth_provider: Node::Provider,
}

impl<P, Node> RethDbProvider<P, Node>
where
    Node: FullNodeTypes<
        Types: NodeTypesWithEngine<
            Engine = OpEngineTypes,
            ChainSpec = OpChainSpec,
            Primitives = OpPrimitives,
        >,
    >,
{
    pub fn new(inner: P, reth_provider: Node::Provider) -> Self {
        Self {
            inner,
            reth_provider,
        }
    }
}

impl<P, Node> Provider<AnyNetwork> for RethDbProvider<P, Node>
where
    P: Provider<AnyNetwork> + Clone,
    Node: FullNodeTypes<
        Types: NodeTypesWithEngine<
            Engine = OpEngineTypes,
            ChainSpec = OpChainSpec,
            Primitives = OpPrimitives,
        >,
    >,
{
    fn root(&self) -> &RootProvider<AnyNetwork> {
        // reth_provider doesn't have a method to get the root provider
        self.inner.root()
    }

    fn get_block_number(&self) -> ProviderCall<NoParams, U64, u64> {
        let best = self
            .reth_provider
            .best_block_number()
            .map_err(TransportErrorKind::custom);
        ProviderCall::ready(best)
    }

    fn get_transaction_count(&self, address: Address) -> RpcWithBlock<Address, U64, u64> {
        let provider = self.reth_provider.clone();
        RpcWithBlock::new_provider(move |block_id| {
            let state = provider.state_by_block_id(block_id).map_err(TransportErrorKind::custom).unwrap();
            let maybe_acc = state.basic_account(&address).map_err(TransportErrorKind::custom).unwrap();
            let nonce = maybe_acc.map(|acc| acc.nonce).unwrap_or_default();

            ProviderCall::ready(Ok(nonce))
        })
    }

    // Is seems like there is no way to implement it in order to call a smart contract
    // fn call(&self, tx: <AnyNetwork as Network>::TransactionRequest) -> EthCall<AnyNetwork, Bytes> {
    //
    // }
}

But still, I couldn't find a way to use FullNodeTypes::Provider to implement the call function.

What is the expected way to make it possible to call smart contracts from within the PayloadBuilder context? Can alloy bindings be used there? If not, what is the canonical approach here? I can't use ethers-rs since the project's type system is based on alloy.

IIUC, I just need to encode the function call and then use reth's EvmEnv to execute it. Using a mocked/dummy provider seems like an ugly workaround and I believe an idiomatic approach should exist.

Any guidance, documentation, or example implementations would be greatly appreciated. Thanks!

[mattsse]

It requires transport in order to communicate with the SC(alloy_provider::Provider).

this shouldn't be the case because then you should have call types that implement:

https://docs.rs/alloy-sol-types/1.0.0/alloy_sol_types/trait.SolCall.html

I suggest to take a look at the expanded code