Ethereum: createProxyWithNonce nested function call?

Ethereum: Creating a Nested Function Call with createProxyWithNonce

When working with the Safe Proxy Factory in Ethereum, deploying a new Gnosis Safe can be a complex process. One common issue arises when trying to create a proxy for a single contract or function using the createProxyWithNonce method.

In this article, we’ll dive into the specifics of how to use the createProxyWithNonce method with nested functions and nonces.

The Problem: Nested Function Calls

Let’s consider an example of deploying a simple Gnosis Safe that uses two contracts:

• SafeContract: This contract provides basic safety features like whitelisting users.

• MyContract: This is the main contract we want to proxy for, which implements a custom logic.

To deploy both contracts via the Safe Proxy Factory using createProxyWithNonce, we’d need to create nested function calls:

MySafe contract {

  function myFunction() internal returns () {

    // Custom logic here...

  }

}


contract SafeContract is SafeProxyFactory {

  function safeFunction() public nonces[0] {

    return myFunction();

  }


  function createProxyWithNonce(

    _singleton,

    initializer, 

    skipNonce

  ) internal override returns (MySafe) {

    MySafe proxy = new MySafe(address(_singleton));

    // Initialize the proxy with some data...

    return proxy;

  }

}

As you can see, we’re creating nested function calls: createProxyWithNonce is being called recursively within another function. This approach has several issues:

• Nested function calls are not allowed: In Solidity, recursive function calls are not supported.

• Nonces are only valid for the first call: Since createProxyWithNonce creates a new instance of MySafe, we’re losing any nonces from the previous call. To fix this, we need to pass the nonce explicitly.

The Solution: Passing Nonces Explicitly

To solve the issues mentioned above, we can modify our approach as follows:

MySafe contract {

  function myFunction() internal returns () {

    // Custom logic here...

  }

}


contract SafeContract is SafeProxyFactory {

  function createProxyWithNonce(

    _singleton,

    initializer, 

    skipNonce

  ) public nonces[0] {

    return new MySafe(address(_singleton));

  }


  function getProxy() internal view returns (MySafe) {

    // Return the proxy instance

  }

}

In this revised approach:

• We pass nonce[0] to the createProxyWithNonce method, which will receive a nonce value for the first call.

• We also define a separate function getProxy() that returns the proxy instance. This allows us to return the proxy instance without needing to rely on nonces.

Conclusion

To create nested function calls with createProxyWithNonce, you need to pass nonces explicitly, either as a parameter or by using an internal view property. By doing so, you can avoid recursive function calls and ensure that your contract is properly initialized.

When deploying Gnosis Safe via the Safe Proxy Factory, make sure to follow these guidelines when creating nested function calls:

• Pass nonces explicitly in createProxyWithNonce methods.

• Use internal view properties for retrieving proxy instances.

Bitcoin Would Sync