As detailed in The JSON-RPC Method eth_simulateV1 is now available on multiple networks, eth_simulateV1 is a powerful tool for conducting advanced simulations on Ethereum.

Recently, we encountered a challenge: simulating a delegate call on an existing contract. This need arose from our desire to test delegate call transactions on Gnosis Safe before committing to the transaction or signing any messages.

For example, with the Transaction Builder extension for Gnosis Safe, you can perform a multi-asset transfer in a single transaction:

Simulating this transaction results in to following view in The Interceptor:

Under normal circumstances, Gnosis Safe executes this transaction by performing a delegate call to a multicall contract to send multiple assets. To simulate this behavior, we aim to replicate the same process but bypass the Gnosis Safe's signature validation checks. To achieve this, we add a custom function to the Gnosis Safe that directly performs the delegate call while skipping these checks. Importantly, the existing functionality of Gnosis Safe must otherwise remain intact, as the multicall contract might call back into the Gnosis Safe.

This approach can be implemented using eth_simulateV1:

1. Relocate the Safe: Move the Safe to a new address, for example, eth:0x0000000000000000000000000000000000920515 (gnosis in leetspeak).

2. Replace the Existing Code: Replace the code of the existing Safe (e.g., eth:0xA06C2B67e7435cE25a5969e49983ec3304D8e787) with a proxy contract. This proxy delegates all calls to the original Safe (0x...920515) except calls to the newly introduced delegateCallExecute function, which performs the delegate call directly.

3. Execute the Delegate Call: Invoke the delegateCallExecute function to perform the desired operation.

Here’s the eth_simulateV1 call that achieves this:

Here's the Solidity contract that we are using in the place of the original Gnosis Safe. its called GnosisSafeProxyProxy, as the original Gnosis safe is already a proxy contract.

// modified from here: https://github.com/safe-global/safe-smart-account/blob/main/contracts/proxies/SafeProxy.sol
pragma solidity 0.8.18;
contract GnosisSafeProxyProxy {
    function delegateCallExecute(address target, bytes memory callData) payable external returns (bytes memory) {
        (bool success, bytes memory returnData) = payable(target).delegatecall(callData);
        require(success, "Delegate call failed");
        return returnData;
    }
    /// forwards all transactions to 0x0000000000000000000000000000000000920515
    fallback() external payable {
        assembly {
            let _originalGnosisSafeProxy := 0x0000000000000000000000000000000000920515
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas(), _originalGnosisSafeProxy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if iszero(success) {
                revert(0, returndatasize())
            }
            return(0, returndatasize())
        }
    }
}

The eth_simulateV1 result will appear as follows. You can observe that two logs are produced, corresponding to two successful USDC transfers.

In this example, we added a new delegate call function to the Gnosis Safe. However, this method is versatile and can be used to add any function to any contract for simulation purposes. This approach is particularly useful for bypassing checks (as demonstrated here), introducing additional get methods to the contract, or performing any other computation directly within the contract. Moreover, the custom functions you write have full access to the existing state of the contract, making this approach even more powerful!

As detailed in The JSON-RPC Method eth_simulateV1 is now available on multiple networks, eth_simulateV1 is a powerful tool for conducting advanced simulations on Ethereum.

Recently, we encountered a challenge: simulating a delegate call on an existing contract. This need arose from our desire to test delegate call transactions on Gnosis Safe before committing to the transaction or signing any messages.

For example, with the Transaction Builder extension for Gnosis Safe, you can perform a multi-asset transfer in a single transaction:

Simulating this transaction results in to following view in The Interceptor:

Under normal circumstances, Gnosis Safe executes this transaction by performing a delegate call to a multicall contract to send multiple assets. To simulate this behavior, we aim to replicate the same process but bypass the Gnosis Safe's signature validation checks. To achieve this, we add a custom function to the Gnosis Safe that directly performs the delegate call while skipping these checks. Importantly, the existing functionality of Gnosis Safe must otherwise remain intact, as the multicall contract might call back into the Gnosis Safe.

This approach can be implemented using eth_simulateV1:

1. Relocate the Safe: Move the Safe to a new address, for example, eth:0x0000000000000000000000000000000000920515 (gnosis in leetspeak).

2. Replace the Existing Code: Replace the code of the existing Safe (e.g., eth:0xA06C2B67e7435cE25a5969e49983ec3304D8e787) with a proxy contract. This proxy delegates all calls to the original Safe (0x...920515) except calls to the newly introduced delegateCallExecute function, which performs the delegate call directly.

3. Execute the Delegate Call: Invoke the delegateCallExecute function to perform the desired operation.

Here’s the eth_simulateV1 call that achieves this:

Here's the Solidity contract that we are using in the place of the original Gnosis Safe. its called GnosisSafeProxyProxy, as the original Gnosis safe is already a proxy contract.

// modified from here: https://github.com/safe-global/safe-smart-account/blob/main/contracts/proxies/SafeProxy.sol
pragma solidity 0.8.18;
contract GnosisSafeProxyProxy {
    function delegateCallExecute(address target, bytes memory callData) payable external returns (bytes memory) {
        (bool success, bytes memory returnData) = payable(target).delegatecall(callData);
        require(success, "Delegate call failed");
        return returnData;
    }
    /// forwards all transactions to 0x0000000000000000000000000000000000920515
    fallback() external payable {
        assembly {
            let _originalGnosisSafeProxy := 0x0000000000000000000000000000000000920515
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas(), _originalGnosisSafeProxy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if iszero(success) {
                revert(0, returndatasize())
            }
            return(0, returndatasize())
        }
    }
}

The eth_simulateV1 result will appear as follows. You can observe that two logs are produced, corresponding to two successful USDC transfers.

In this example, we added a new delegate call function to the Gnosis Safe. However, this method is versatile and can be used to add any function to any contract for simulation purposes. This approach is particularly useful for bypassing checks (as demonstrated here), introducing additional get methods to the contract, or performing any other computation directly within the contract. Moreover, the custom functions you write have full access to the existing state of the contract, making this approach even more powerful!