[wip] feat: multicall context manager

[omarish]

What I did

This is a rough first draft at a multicall context manager. It doesn't work yet but sharing it here to get feedback before I go deeper into implementation.

Related issue: #1011

How I did it

How to verify it

What Remains

• Thread safety
• Making it so that using the MulticallContextManager (multicall) enables the middleware

Checklist

• I have confirmed that my PR passes all linting checks
• I have included test cases
• I have updated the documentation
• I have added an entry to the changelog

[banteg]

I've played with it quite a bit too, a few thoughts:

Multicall as middleware won't work, it requires patching web3 internals too deeply, and possibly replacing web3 provider.

A better way might be yielding a caller decorator from the context manager which intercepts function calls, generates the calldata using encode_input and stores a decode_output reference. This could potentially also work with automatic flushing of the queue as was originally envisioned since you have the idea of the argument types before yielding futures.

What I haven't solved so far is keeping the API the same. I don't like that it adds this .result() requirement.

This is what I got so far:

from concurrent.futures import Future
from contextlib import contextmanager
from functools import partial


class Caller:
    def __init__(self, queue, contract=None, func=None):
        self.queue = queue
        self.contract = contract
        self.func = func

    def __getattr__(self, name):
        return Caller(self.queue, self.contract, getattr(self.contract, name))

    def __call__(self, *args, **kwds):
        future = Future()
        future.call = [str(self.contract), self.func.encode_input(*args, **kwds)]
        future.decode_output = self.func.decode_output
        self.queue.append(future)
        return future


@contextmanager
def multicall_context():
    """
    with multicall_context() as caller:
        response = caller(contract).func(args)

    response.result()
    """
    queue = []
    yield partial(Caller, queue)  # caller(contract).func(args).result()

    block, results = multicall.aggregate.call([request.call for request in queue])

    for request, result in zip(queue, results):
        request.set_result(request.decode_output(result))

A full example:

def main():
    vault = Contract("0x5dbcF33D8c2E976c6b560249878e6F1491Bca25c")

    with multicall_context() as caller:
        assets = caller(vault).balance()  # can't call result before exiting
        pps = caller(vault).getPricePerFullShare()

    print(assets.result().to('ether') * pps.result().to('ether'))

[spinoch]

What I haven't solved so far is keeping the API the same. I don't like that it adds this .result() requirement.

Could use ContextManager.__exit__ to take care of that (?)