# eth_multicall test suite tutorial This is a guide on how to write test cases for eth_multicall and execute them. There are several pieces to this puzzle: - Tests are implemented in [rpctestgen](https://github.com/lightclient/rpctestgen) which outputs IO (Json-rpc request response sequence) artefacts. - `.io` files are copied over to Hive simulation `rpc-compat` - Then we can execute the tests against a client using Hive CLI Now let's go over them one by one. ## Rpctestgen This is a tool written in Go. It creates a chain from code and starts a Geth node with that. The test cases describe the request to be made which is then sent to geth to fill in the response. The test case can do validation of the response and optionally fail to generate the artefact. There are a few basic test cases in this branch: https://github.com/s1na/rpctestgen/tree/multicall that can act as a sample for writing new ones. First, clone the repo at this branch: ```terminal git clone --branch multicall https://github.com/s1na/rpctestgen.git cd rpctestgen ``` To fill in the tests you need to have a geth binary with multicall support. ```terminal git clone --branch multicall --depth 5 https://github.com/s1na/go-ethereum.git cd go-ethereum make geth ``` This will put the binary at `/path/go-ethereum/build/bin/geth`. Run: ```terminal PATH=$PATH:/path/to/geth/binary make fill ``` The output files are written in the `tests/` dir. ## Hive suite rpc-compat ### Setup simulator Clone Hive. Copy the generated tests to the rpc-compat simulation (under `simulators/ethereum/rpc-compat/tests`). Then you need to modify the Docker file located at `simulators/ethereum/rpc-compat/Dockerfile` to use the tests in that directory instead of fetching them from `execution-apis` repo. Apply this patch (basically comment the `git clone` and uncomment `ADD tests /execution-apis/tests`). ```patch diff --git a/simulators/ethereum/rpc-compat/Dockerfile b/simulators/ethereum/rpc-compat/Dockerfile index d338a2c..79d6a53 100644 --- a/simulators/ethereum/rpc-compat/Dockerfile +++ b/simulators/ethereum/rpc-compat/Dockerfile @@ -3,11 +3,11 @@ FROM golang:1-alpine as builder RUN apk add --update git ca-certificates gcc musl-dev linux-headers # Clone the tests repo. -RUN git clone --depth 1 https://github.com/ethereum/execution-apis.git /execution-apis +#RUN git clone --depth 1 https://github.com/ethereum/execution-apis.git /execution-apis # To run local tests, copy the directory into the same as the simulator and # uncomment the line below -# ADD tests /execution-apis/tests +ADD tests /execution-apis/tests # Build the simulator executable. ADD . /source ``` ### Execute There is a few ways to do this, depending on whether you'd want to run against a published docker container of the client, a git branch, or source code locally. Each client in Hive has three docker files, one for each of this approaches. Here I highlight how to do this against a git branch of geth. Create a `clients.yaml` file: ```yaml= - client: go-ethereum dockerfile: git build_args: github: s1na/go-ethereum tag: multicall ``` then run: ```bash go build . # build hive ./hive --sim rpc-compat --client-file clients.yaml ``` This should run the whole rpc-compat test suite (which we added to the `tests` directory) against the clients configured in `clients.yaml`. If you needed more verbosity you can add `--docker.output` flag to the hive command.
Last changed by  
 
Sina Mahmoodi
242

Read more

7002 withdrawal schedule

Adding a withdrawal requests to the queue costs 74160 gas per call, which means you can add ~480 withdrawals per block. Within two blocks, the fee to add more withdrawals to the queue will take roughly 2.6 million ETH in the next block. The amount of ETH needed to add another withdrawal will go down over the next blocks, but the curve of the increase is extremely steep. You can kinda think of it as if the 12.5% increase per block of 1559 is only applied every 480 blocks. So whenever this increase applied, the fee not only goes up by 12.5% but by (12.5%)^480, thus the fee increases quite suddenly. The fee will slowly go down on every block, but it will take 126 blocks until the fee is below 1 ETH to add a withdrawal to the queue. This means that an attacker can grief staking pools quite easily. NUMBERS

3/4/2025
Onchain day 6

Kurtosis challenge To run Kurtosis, you will need Docker. Check out the installation docs for Docker. Then see how to install Kurtosis. This is the configuration we will be using for our private network. It will include 3 nodes. 2 Geth<->Lighthouse pairs and one Geth<->Teku pair. It will additionally run dora the blockchain explorer. Save the following to a file basic.yaml. participants: - el_type: geth cl_type: lighthouse

2/13/2025
Writing a testcase for graphql

I'm adding a testcase for EIP-4844 which will be shipped in the Cancun hardfork. The graphql schema will change to include the additional fields in the block and transaction data structures. Refer to https://github.com/ethereum/execution-apis/pull/468 for the schema changes. The graphql simulator https://github.com/ethereum/hive/tree/master/simulators/ethereum/graphql comes with a chain. However this chain does not include 4844 blocks. So we need to update the chain and add new blocks + txes. For that we use https://github.com/s1na/graphqltestgen. graphqltestgen This tool is used to extend an existing chain which at first consisted of only frontier blocks and later extended with post-merge blocks. The benefit here is we can test the response at fork boundaries too. It takes in a genesis configuration assumed to be at ./genesis.json and the RLP-serialized list of blocks at ./chain.rlp. Note: you need to modify the code to implement the kind of block you want to add. The new chain will be written to ./newchain.rlp. Note since the merge forks happen after a given timestamp. Since the new block should be Cancun, the genesis file must be modified with a value for "cancunTime". To calculate the value, we need to know the timestamp of the last block. This is because the chain generator will automatically assign parentBlock + 10 as the timestamp of any new block. So I print the current header with go run main.go head to find out the latest timestamp.

10/3/2023
state

tracer hooks OnBalanceChange(addr common.Address, prev, new *big.Int, reason BalanceChangeReason) OnNonceChange(addr common.Address, prev, new uint64) OnCodeChange(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte) OnStorageChange(addr common.Address, slot common.Hash, prev, new common.Hash) OnLog(log *types.Log) OnNewAccount(addr common.Address) blockchain

8/8/2023
Read more from Sina Mahmoodi
Published on HackMD